@codeyam/codeyam-cli 0.1.0-staging.8e7b1bd → 0.1.0-staging.b8a55ba

package/analyzer-template/packages/ai/src/lib/worker/analyzeScopeWorker.ts

@@ -8,7 +8,10 @@
 import { Entity } from '~codeyam/types';
 import { FileAnalyzer, ProjectAnalyzer } from '~codeyam/analyze';
 import { analyzeScopeLocal } from '../analyzeScope';
-import { ScopeInfo } from '../dataStructure/ScopeDataStructure';
+import {
+  ScopeInfo,
+  resetScopeDataStructureMetrics,
+} from '../dataStructure/ScopeDataStructure';
 import { SerializableDataStructure } from './SerializableDataStructure';
 import { AI } from '~codeyam/ai';
 import { setThreadContext } from '~codeyam/utils';
@@ -48,6 +51,10 @@ let fileAnalyzerPath: string | null = null;
 export default async function runAnalyzeScope(
   input: AnalyzeScopeWorkerInput,
 ): Promise<AnalyzeScopeWorkerOutput> {
+  // Reset metrics counters at the start of each entity analysis to prevent
+  // false "infinite loop" detection when processing multiple entities
+  resetScopeDataStructureMetrics();
+
   try {
     const { entity, project, dirPath, filePath, file, scope, model } = input;
 

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

@@ -17,6 +17,10 @@ import {
 } from '~codeyam/ai';
 import type { AnalysisOptions } from '../analyzeEntities';
 
+// VERSION MARKER: server-only-detection-v2 (2025-12-28)
+// This version includes automatic detection of "use server" and "server-only" files
+// and runs server-only detection even for cached entities
+
 /**
  * PHASE 2: Prepare entity data structures
  * Generate data structures for all entities upfront, before graph traversal.
@@ -30,157 +34,237 @@ export default async function prepareEntityDataStructures(
   // Process entities in parallel for speed
   await Promise.all(
     Array.from(allEntities).map(async (entity) => {
-      // Skip if already has cached data structure (unless force is set)
+      // Check if already has cached data structure (unless force is set)
       const hasCache = !!entity.metadata?.isolatedDataStructure;
-      if (hasCache && !options.force && !options.forceAll) {
-        return;
-      }
-
-      try {
-        const fileAnalyzer = projectAnalyzer.getFileAnalyzerByPath(
-          entity.resolvedFilePath ?? entity.filePath,
-        );
-        if (!fileAnalyzer) {
-          awsLog(
-            `CodeYam: prepareEntityDataStructures: FileAnalyzer not found`,
-            {
-              entityFilePath: entity.filePath,
-              entityName: entity.name,
-            },
+      const shouldRegenerateDataStructure =
+        !hasCache || options.force || options.forceAll;
+
+      // PHASE 1: Generate data structure (only for non-cached entities or when forced)
+      // Wrapped in its own try-catch so PHASE 2 always runs even if this fails
+      if (shouldRegenerateDataStructure) {
+        try {
+          const fileAnalyzer = projectAnalyzer.getFileAnalyzerByPath(
+            entity.resolvedFilePath ?? entity.filePath,
           );
-          return;
-        }
-
-        const dataStructureInfo = await getEntityDataStructureAndFunctionCalls({
-          entity,
-          fileAnalyzer,
-        });
-
-        if (!dataStructureInfo?.isolatedDataStructure) {
-          // Data structure generation failed - entity will proceed with empty schemas
-          // This is okay - the entity can still be analyzed, just without detailed type info
-          if (['visual', 'library'].includes(entity.entityType)) {
-            // we'd really expect these to have data structures
+          if (!fileAnalyzer) {
             awsLog(
-              `CodeYam: prepareEntityDataStructures: Failed to generate data structure for ${entity.filePath}:${entity.name}`,
+              `CodeYam: prepareEntityDataStructures: FileAnalyzer not found`,
+              {
+                entityFilePath: entity.filePath,
+                entityName: entity.name,
+              },
             );
-          }
-          return;
-        }
+            // Still continue to PHASE 2 for server-only detection
+          } else {
+            const dataStructureInfo =
+              await getEntityDataStructureAndFunctionCalls({
+                entity,
+                fileAnalyzer,
+              });
+
+            if (!dataStructureInfo?.isolatedDataStructure) {
+              // Data structure generation failed - entity will proceed with empty schemas
+              // This is okay - the entity can still be analyzed, just without detailed type info
+              if (['visual', 'library'].includes(entity.entityType)) {
+                // we'd really expect these to have data structures
+                awsLog(
+                  `CodeYam: prepareEntityDataStructures: Failed to generate data structure for ${entity.filePath}:${entity.name}`,
+                );
+              }
+              // Still continue to PHASE 2 for server-only detection
+            } else {
+              const {
+                isolatedDataStructure,
+                functionCalls,
+                callVariableNames,
+              } = dataStructureInfo;
+
+              // Store data structure in entity metadata
+              entity.metadata ||= {};
+
+              // Deep clone dependencySchemas to avoid shared references
+              // We need to clone because getReturnValue() returns direct references to schema objects
+              // and multiple entities might reference the same dependency
+              const clonedDependencySchemas: typeof isolatedDataStructure.dependencySchemas =
+                {};
+              for (const filePath in isolatedDataStructure.dependencySchemas) {
+                clonedDependencySchemas[filePath] = {};
+                for (const entityName in isolatedDataStructure
+                  .dependencySchemas[filePath]) {
+                  const depSchema =
+                    isolatedDataStructure.dependencySchemas[filePath][
+                      entityName
+                    ];
+                  clonedDependencySchemas[filePath][entityName] = {
+                    signatureSchema: { ...depSchema.signatureSchema },
+                    returnValueSchema: { ...depSchema.returnValueSchema },
+                    usageEquivalencies: depSchema.usageEquivalencies,
+                    sourceEquivalencies: depSchema.sourceEquivalencies,
+                  };
+                }
+              }
 
-        const { isolatedDataStructure, functionCalls, callVariableNames } =
-          dataStructureInfo;
-
-        // Store data structure in entity metadata
-        entity.metadata ||= {};
-
-        // Deep clone dependencySchemas to avoid shared references
-        // We need to clone because getReturnValue() returns direct references to schema objects
-        // and multiple entities might reference the same dependency
-        const clonedDependencySchemas: typeof isolatedDataStructure.dependencySchemas =
-          {};
-        for (const filePath in isolatedDataStructure.dependencySchemas) {
-          clonedDependencySchemas[filePath] = {};
-          for (const entityName in isolatedDataStructure.dependencySchemas[
-            filePath
-          ]) {
-            const depSchema =
-              isolatedDataStructure.dependencySchemas[filePath][entityName];
-            clonedDependencySchemas[filePath][entityName] = {
-              signatureSchema: { ...depSchema.signatureSchema },
-              returnValueSchema: { ...depSchema.returnValueSchema },
-              usageEquivalencies: depSchema.usageEquivalencies,
-              sourceEquivalencies: depSchema.sourceEquivalencies,
-            };
-          }
-        }
+              entity.metadata.isolatedDataStructure = {
+                signatureSchema: deduplicateFunctionSchemas(
+                  isolatedDataStructure.signatureSchema,
+                ),
+                returnValueSchema: deduplicateFunctionSchemas(
+                  isolatedDataStructure.returnValueSchema,
+                ),
+                equivalentSignatureVariables:
+                  isolatedDataStructure.equivalentSignatureVariables,
+                dependencySchemas: clonedDependencySchemas,
+                environmentVariables:
+                  isolatedDataStructure.environmentVariables,
+                // Use enriched conditional usages with source tracing from analysis
+                conditionalUsages: isolatedDataStructure.conditionalUsages,
+                // Include root entity's equivalencies for merge step
+                usageEquivalencies: isolatedDataStructure.usageEquivalencies,
+                sourceEquivalencies: isolatedDataStructure.sourceEquivalencies,
+              };
+
+              // Detect wrapper requirements (Context providers, etc.)
+              const wrapperRequirements = detectWrapperRequirements({
+                entity,
+                fileAnalyzer,
+              });
+              if (wrapperRequirements.length > 0) {
+                entity.metadata.wrapperRequirements = wrapperRequirements;
+              }
 
-        entity.metadata.isolatedDataStructure = {
-          signatureSchema: deduplicateFunctionSchemas(
-            isolatedDataStructure.signatureSchema,
-          ),
-          returnValueSchema: deduplicateFunctionSchemas(
-            isolatedDataStructure.returnValueSchema,
-          ),
-          equivalentSignatureVariables:
-            isolatedDataStructure.equivalentSignatureVariables,
-          dependencySchemas: clonedDependencySchemas,
-          environmentVariables: isolatedDataStructure.environmentVariables,
-          // Use enriched conditional usages with source tracing from analysis
-          conditionalUsages: isolatedDataStructure.conditionalUsages,
-        };
+              // Annotate imported exports with function call information
+              const importedExports = entity.metadata.importedExports ?? [];
+              for (const importedExport of importedExports) {
+                const relevantCalls = functionCalls[importedExport.name];
+                if (relevantCalls) {
+                  importedExport.calls = relevantCalls;
+                }
+                const relevantVariableNames =
+                  callVariableNames[importedExport.name];
+                if (relevantVariableNames) {
+                  importedExport.callVariableNames = relevantVariableNames;
+                }
+              }
 
-        // Detect wrapper requirements (Context providers, etc.)
-        const wrapperRequirements = detectWrapperRequirements({
-          entity,
-          fileAnalyzer,
-        });
-        if (wrapperRequirements.length > 0) {
-          entity.metadata.wrapperRequirements = wrapperRequirements;
+              // Annotate node module imports with function call information
+              for (const [path, infos] of Object.entries(
+                entity.metadata.nodeModuleImports ?? {},
+              )) {
+                for (const info of infos) {
+                  const relevantCalls = functionCalls[info.name];
+                  if (relevantCalls) {
+                    info.calls = relevantCalls;
+                  }
+                  const relevantVariableNames = callVariableNames[info.name];
+                  if (relevantVariableNames) {
+                    info.callVariableNames = relevantVariableNames;
+                  }
+                }
+              }
+            }
+          }
+        } catch (phase1Error) {
+          console.warn(
+            `CodeYam: prepareEntityDataStructures: PHASE 1 error for ${entity.filePath}:${entity.name}:`,
+            phase1Error,
+          );
+          // Continue to PHASE 2 - server-only detection should still run
         }
+      }
 
-        // Annotate imported exports with function call information
-        const importedExports = entity.metadata.importedExports ?? [];
+      try {
+        // PHASE 2: Server-only detection and isMocked determination
+        // This runs for ALL entities, even those with cached data structures
+        // because server-only detection may have been added after the entity was cached
+        const importedExports = entity.metadata?.importedExports ?? [];
+        const mockedDependencies = determineMockedDependencies(entity);
         for (const importedExport of importedExports) {
-          const relevantCalls = functionCalls[importedExport.name];
-          if (relevantCalls) {
-            importedExport.calls = relevantCalls;
-          }
-          const relevantVariableNames = callVariableNames[importedExport.name];
-          if (relevantVariableNames) {
-            importedExport.callVariableNames = relevantVariableNames;
+          // Skip if already has a definitive isMocked value (true or false, not null)
+          // But re-check if isMocked is null or undefined - this handles previously cached entities
+          if (
+            importedExport.isMocked === true ||
+            importedExport.isMocked === false
+          ) {
+            console.log(
+              `CodeYam: [${entity.name}] SKIP ${importedExport.name} - already has isMocked=${importedExport.isMocked}`,
+            );
+            continue;
           }
-        }
 
-        // Annotate node module imports with function call information
-        for (const [path, infos] of Object.entries(
-          entity.metadata.nodeModuleImports ?? {},
-        )) {
-          for (const info of infos) {
-            const relevantCalls = functionCalls[info.name];
-            if (relevantCalls) {
-              info.calls = relevantCalls;
-            }
-            const relevantVariableNames = callVariableNames[info.name];
-            if (relevantVariableNames) {
-              info.callVariableNames = relevantVariableNames;
-            }
+          // Never mock visual components - they render UI and should use real implementation
+          if (importedExport.entityType === 'visual') {
+            console.log(
+              `CodeYam: [${entity.name}] SKIP ${importedExport.name} - visual component, setting isMocked=false`,
+            );
+            importedExport.isMocked = false;
+            continue;
           }
-        }
 
-        // Determine and mark mocked dependencies
-        const mockedDependencies = determineMockedDependencies(entity);
-        for (const importedExport of importedExports) {
-          if (importedExport.isMocked === undefined) {
-            // Never mock visual components - they render UI and should use real implementation
-            if (importedExport.entityType === 'visual') {
-              importedExport.isMocked = false;
-              continue;
-            }
+          // Always mock imports from server-only files ("use server" or import "server-only")
+          // These files contain Server Actions or server-only code that cannot run on the client
+          const importedFilePath =
+            importedExport.resolvedFilePath ?? importedExport.filePath;
+          const importedFileAnalyzer =
+            projectAnalyzer.getFileAnalyzerByPath(importedFilePath);
+          // Use sourceFile.getText() which is always available, unlike file.content which is lazy-loaded
+          const importedFileContent =
+            importedFileAnalyzer?.sourceFile?.getText();
+
+          const isServerOnly = importedFileContent
+            ? isServerOnlyFile(importedFileContent)
+            : false;
+          console.log(
+            `CodeYam: [${entity.name}] CHECK ${importedExport.name} from ${importedFilePath}:`,
+            {
+              hasFileAnalyzer: !!importedFileAnalyzer,
+              hasSourceFile: !!importedFileAnalyzer?.sourceFile,
+              hasFileContent: !!importedFileContent,
+              contentFirst50Chars: importedFileContent
+                ?.substring(0, 50)
+                ?.replace(/\n/g, '\\n'),
+              isServerOnly,
+            },
+          );
 
-            importedExport.isMocked = mockedDependencies.some(
-              (dep) =>
-                dep.filePath === importedExport.filePath &&
-                dep.entityName === importedExport.name,
+          if (importedFileContent && isServerOnly) {
+            console.log(
+              `CodeYam: [${entity.name}] ✓ MARKING ${importedExport.name} as isMocked=true (server-only file detected)`,
             );
+            importedExport.isMocked = true;
+            continue;
           }
+
+          const matchesMockedDep = mockedDependencies.some(
+            (dep) =>
+              dep.filePath === importedExport.filePath &&
+              dep.entityName === importedExport.name,
+          );
+          importedExport.isMocked = matchesMockedDep;
+          console.log(
+            `CodeYam: [${entity.name}] ${importedExport.name} isMocked=${matchesMockedDep} (from mockedDependencies)`,
+          );
         }
 
         // Browser globals that should always be mocked (they make network calls)
         const alwaysMockedBrowserGlobals = ['fetch', 'EventSource'];
 
         for (const [path, infos] of Object.entries(
-          entity.metadata.nodeModuleImports ?? {},
+          entity.metadata?.nodeModuleImports ?? {},
         )) {
           for (const info of infos) {
-            if (info.isMocked === undefined) {
+            if (info.isMocked === undefined || info.isMocked === null) {
               // Browser globals should always be mocked
               if (alwaysMockedBrowserGlobals.includes(path)) {
                 info.isMocked = true;
               } else {
+                // Check if this dependency should be mocked
+                // Match both exact entityName and variable-qualified entityNames
+                // e.g., "useFetcher" matches "useFetcher" OR "useFetcher::userFetcher"
                 info.isMocked = mockedDependencies.some(
                   (dep) =>
-                    dep.filePath === path && dep.entityName === info.name,
+                    dep.filePath === path &&
+                    (dep.entityName === info.name ||
+                      dep.entityName.startsWith(info.name + '::')),
                 );
               }
             }
@@ -269,6 +353,104 @@ async function getEntityDataStructureAndFunctionCalls({
           getSourceEquivalencies(dataStructure, importedExport.name) ?? {},
       };
 
+      // Also create variable-qualified entries to preserve distinct return type schemas
+      // when the same function is called multiple times with different type parameters
+      // (e.g., useFetcher<UserData>() vs useFetcher<ReportData>()).
+      //
+      // Each parameterized call is a SEPARATE entry in externalFunctionCalls, so we need
+      // to iterate over ALL matching calls (not just the first one).
+      const matchingCalls = dataStructure.externalFunctionCalls.filter(
+        (fc) =>
+          fc.name === importedExport.name ||
+          fc.name.startsWith(importedExport.name + '<'),
+      );
+
+      // Track how many times each variable name has been seen across ALL matching calls
+      // This handles the case where multiple parameterized calls (e.g., useFetcher<ConfigData>,
+      // useFetcher<SettingsData>) assign to the same variable name
+      const varNameCounts: Record<string, number> = {};
+
+      for (const efc of matchingCalls) {
+        // Check if this call has perVariableSchemas (multiple calls with same signature)
+        if (efc?.perVariableSchemas) {
+          for (const [varName, perVarSchema] of Object.entries(
+            efc.perVariableSchemas,
+          )) {
+            // Track occurrences of this variable name
+            const occurrence = varNameCounts[varName] ?? 0;
+            varNameCounts[varName] = occurrence + 1;
+
+            // Use indexed key if variable name is reused (e.g., fetcher, fetcher[1])
+            const indexedVarName =
+              occurrence === 0 ? varName : `${varName}[${occurrence}]`;
+            const qualifiedKey = `${importedExport.name}::${indexedVarName}`;
+            acc[importedExport.filePath][qualifiedKey] = {
+              signatureSchema: deduplicateFunctionSchemas({
+                ...signatureSchema,
+              }),
+              returnValueSchema: deduplicateFunctionSchemas({
+                ...perVarSchema,
+              }),
+              usageEquivalencies:
+                getUsageEquivalencies(dataStructure, importedExport.name) ?? {},
+              sourceEquivalencies:
+                getSourceEquivalencies(dataStructure, importedExport.name) ??
+                {},
+            };
+          }
+        } else if (efc?.receivingVariableNames?.length === 1) {
+          // For parameterized calls like useFetcher<UserData>(), each is a separate entry
+          // with a single receivingVariableName. Create a variable-qualified entry using
+          // the specific return value for this parameterized call.
+          const varName = efc.receivingVariableNames[0];
+
+          // Track occurrences of this variable name across all efc entries
+          const occurrence = varNameCounts[varName] ?? 0;
+          varNameCounts[varName] = occurrence + 1;
+
+          // Use indexed key if variable name is reused (e.g., fetcher, fetcher[1])
+          const indexedVarName =
+            occurrence === 0 ? varName : `${varName}[${occurrence}]`;
+          const qualifiedKey = `${importedExport.name}::${indexedVarName}`;
+
+          // PREFER perVariableSchemas over getReturnValue() when available
+          // perVariableSchemas has the SPECIFIC schema for this parameterized call,
+          // while getReturnValue() may return merged schemas from multiple calls
+          let parameterizedReturnValue: Record<string, string> | null = null;
+
+          if (efc.perVariableSchemas && efc.perVariableSchemas[varName]) {
+            // Use the specific schema from perVariableSchemas
+            parameterizedReturnValue = efc.perVariableSchemas[varName] ?? null;
+          }
+
+          // Fallback to getReturnValue if perCallSignatureSchemas not available
+          if (!parameterizedReturnValue) {
+            parameterizedReturnValue = getReturnValue(dataStructure, {
+              functionName: efc.name, // Use the full parameterized name
+            });
+          }
+
+          if (
+            parameterizedReturnValue &&
+            Object.keys(parameterizedReturnValue).length > 0
+          ) {
+            acc[importedExport.filePath][qualifiedKey] = {
+              signatureSchema: deduplicateFunctionSchemas({
+                ...signatureSchema,
+              }),
+              returnValueSchema: deduplicateFunctionSchemas({
+                ...parameterizedReturnValue,
+              }),
+              usageEquivalencies:
+                getUsageEquivalencies(dataStructure, importedExport.name) ?? {},
+              sourceEquivalencies:
+                getSourceEquivalencies(dataStructure, importedExport.name) ??
+                {},
+            };
+          }
+        }
+      }
+
       return acc;
     },
     {} as {
@@ -301,6 +483,9 @@ async function getEntityDataStructureAndFunctionCalls({
   // Get enriched conditional usages with source tracing
   const conditionalUsages = getConditionalUsages(dataStructure);
 
+  const rawUsageEquivalencies = getUsageEquivalencies(dataStructure);
+  const rawSourceEquivalencies = getSourceEquivalencies(dataStructure);
+
   const isolatedDataStructure = {
     signatureSchema: deduplicateFunctionSchemas(clonedRawSignature),
     returnValueSchema: deduplicateFunctionSchemas(clonedRawReturnValue),
@@ -310,6 +495,11 @@ async function getEntityDataStructureAndFunctionCalls({
     environmentVariables: dataStructure.environmentVariables,
     conditionalUsages:
       Object.keys(conditionalUsages).length > 0 ? conditionalUsages : undefined,
+    // Include root entity's equivalencies so they can be used during merge.
+    // These show how the parent's data flows to/from child components.
+    // E.g., for SurveysList, usageEquivalencies shows surveys[] → SurveyCard().signature[0].survey
+    usageEquivalencies: rawUsageEquivalencies ?? {},
+    sourceEquivalencies: rawSourceEquivalencies ?? {},
   };
 
   const functionCalls: Record<string, string[]> = {};
@@ -322,31 +512,6 @@ async function getEntityDataStructureAndFunctionCalls({
         efc.callSignature.startsWith(entityName),
       );
 
-      // DEBUG: Log external function calls info for useFetcher
-      if (entityName === 'useFetcher' || entityName.includes('Fetcher')) {
-        console.log(
-          'CodeYam DEBUG prepareDataStructures:',
-          JSON.stringify(
-            {
-              entityName,
-              filePath,
-              totalExternalFunctionCalls:
-                dataStructure.externalFunctionCalls.length,
-              matchingCallsCount: matchingCalls.length,
-              matchingCalls: matchingCalls.map((efc) => ({
-                name: efc.name,
-                callSignature: efc.callSignature,
-                allCallSignatures: efc.allCallSignatures,
-                receivingVariableNames: efc.receivingVariableNames,
-                callSignatureToVariable: efc.callSignatureToVariable,
-              })),
-            },
-            null,
-            2,
-          ),
-        );
-      }
-
       // Collect all call signatures from all matching efc entries
       // Each efc may have just one callSignature, or allCallSignatures if merged
       const allSignatures: string[] = [];
@@ -631,3 +796,32 @@ export function determineMockedDependencies(entity: Entity) {
 
   return mockedEntities;
 }
+
+/**
+ * Check if a file is server-only based on its content.
+ *
+ * A file is considered server-only if it:
+ * 1. Starts with "use server" directive (Server Actions in Next.js)
+ * 2. Contains import "server-only" (explicit server-only marker)
+ *
+ * Server-only files should always be mocked when imported by client components
+ * because they contain code that cannot run in the browser.
+ */
+export function isServerOnlyFile(fileContent: string): boolean {
+  const trimmed = fileContent.trimStart();
+
+  // Check for "use server" directive at the start of the file
+  if (
+    trimmed.startsWith('"use server"') ||
+    trimmed.startsWith("'use server'")
+  ) {
+    return true;
+  }
+
+  // Check for server-only import anywhere in the file
+  if (/import\s+["']server-only["']/.test(fileContent)) {
+    return true;
+  }
+
+  return false;
+}

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

@@ -499,7 +499,23 @@ export default async function analyzeEntities({
 
     const successfullyUpdated: Analysis[] = [];
 
+    console.log('CodeYam DEBUG: updateReadyAnalyses - newlyReady analyses:', {
+      count: newlyReady.length,
+      analyses: newlyReady.map((a) => ({
+        id: a.id,
+        filePath: a.filePath,
+        entityName: a.entityName,
+        scenarioCount: a.scenarios?.length ?? 0,
+      })),
+    });
+
     for (const analysis of newlyReady) {
+      console.log('CodeYam DEBUG: Setting readyToBeCaptured=true for:', {
+        id: analysis.id,
+        filePath: analysis.filePath,
+        entityName: analysis.entityName,
+      });
+
       const updatedStatus = await updateFreshAnalysisStatus(
         analysis.id!,
         (status) => {
@@ -511,6 +527,10 @@ export default async function analyzeEntities({
       if (updatedStatus) {
         analysis.status = updatedStatus;
         successfullyUpdated.push(analysis);
+        console.log('CodeYam DEBUG: Successfully marked readyToBeCaptured:', {
+          id: analysis.id,
+          entityName: analysis.entityName,
+        });
       } else {
         console.warn(
           `CodeYam: updateReadyAnalyses: Failed to update status for analysis ${analysis.id}`,

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

@@ -204,6 +204,13 @@ export default function getImportedExports(
           }
           const resolvedName = importedExportInfo.exportName;
 
+          // When a default export is re-exported as named (e.g., `export { default as X }`),
+          // isExportDefault will be false (it's exported as named from the barrel),
+          // but resolvedName will be 'default'. In this case, we need resolvedIsDefault
+          // to be true so that writeScenarioComponents adds the named re-export.
+          const resolvedIsDefault =
+            importedExportInfo.isExportDefault || resolvedName === 'default';
+
           return {
             fileId: importedExportFile.id,
             filePath: actualResolvedPath,
@@ -213,7 +220,7 @@ export default function getImportedExports(
                 ? undefined
                 : resolvedFilePath,
             resolvedName: resolvedName === name ? undefined : resolvedName,
-            resolvedIsDefault: importedExportInfo.isExportDefault,
+            resolvedIsDefault,
             entityType,
             name,
             code,