@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.c90f8c9

package/analyzer-template/project/writeScenarioComponents.ts

@@ -97,11 +97,15 @@ function resetDebugTiming(): void {
  */
 function findEndOfImports(content: string): number {
   try {
+    // Use temp.tsx to enable JSX parsing - otherwise TypeScript may misparse
+    // JSX content containing the word "import" (e.g., "Entities that import this")
+    // as an import statement, causing mock code to be inserted in the wrong location.
     const sourceFile = ts.createSourceFile(
-      'temp.ts',
+      'temp.tsx',
       content,
       ts.ScriptTarget.Latest,
       true,
+      ts.ScriptKind.TSX,
     );
 
     let lastImportEnd = 0;
@@ -710,11 +714,13 @@ function extractInternalImportPathsAst(fileContent: string): string[] {
   const importPaths: string[] = [];
 
   try {
+    // Use temp.tsx to enable JSX parsing for consistent handling of JSX files
     const sourceFile = ts.createSourceFile(
-      'temp.ts',
+      'temp.tsx',
       fileContent,
       ts.ScriptTarget.Latest,
       true,
+      ts.ScriptKind.TSX,
     );
 
     for (const statement of sourceFile.statements) {
@@ -864,11 +870,42 @@ function addMockToContent(
 
   // Check if we have multiple calls with different variable names
   // This requires generating separate mock functions for each call site
+  //
+  // IMPORTANT: calls array may contain BOTH base hook calls (e.g., "useFetcher<Type>()")
+  // AND method chain usages (e.g., "useFetcher().functionCallReturnValue.submit(...)").
+  // We only want to count base hook calls for the length comparison with callVariableNames.
+  // A "base call" is one that ends with "()" possibly preceded by a type annotation,
+  // without any subsequent method chains like ".functionCallReturnValue" or ".submit(...)".
+  const baseHookCalls = importedExport.calls?.filter((call) => {
+    // Base hook calls match patterns like:
+    // - "useFetcher()"
+    // - "useFetcher<Type>()"
+    // - "useFetcher<{ complex: Type }>()"
+    // They end with "()" and don't have method chains after the call.
+    // Method chains contain ".functionCallReturnValue" or have property access after "()".
+    return (
+      call.endsWith('()') &&
+      !call.includes('.functionCallReturnValue') &&
+      // Also exclude method chains like "hook().something" or "hook().method()"
+      !call.match(/\(\)\.[a-zA-Z]/)
+    );
+  });
+
+  // Determine if we can generate unique mock functions for multiple variables.
+  // We need:
+  // 1. Multiple variable names (callVariableNames.length > 1)
+  // 2. Base hook calls to match them (baseHookCalls.length > 0)
+  // Note: We use min(baseHookCalls.length, callVariableNames.length) for iteration
+  // to handle cases where data might be slightly out of sync (stale entries).
   const hasMultipleCallsWithVariables =
-    importedExport.calls &&
-    importedExport.calls.length > 1 &&
+    baseHookCalls &&
+    baseHookCalls.length > 1 &&
     importedExport.callVariableNames &&
-    importedExport.callVariableNames.length === importedExport.calls.length;
+    importedExport.callVariableNames.length > 1 &&
+    // Only proceed if we have at least as many base calls as variable names,
+    // OR they're close enough (within 1) to handle minor sync issues
+    Math.abs(baseHookCalls.length - importedExport.callVariableNames.length) <=
+      1;
 
   let mockCode: string | undefined;
   const variableMockCodes: string[] = [];
@@ -877,27 +914,28 @@ function addMockToContent(
     // Generate separate mock functions for each variable-qualified call
     // Look up canonical keys from dataForMocks and track variable names for function naming
 
-    // Get all canonical keys for this hook (sorted by index)
+    // Get all call signature keys for this hook from dataForMocks
     const dataForMocks =
       rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
-    const canonicalKeysForHook = dataForMocks
-      ? Object.keys(dataForMocks)
-          .filter((key) => {
-            const match = key.match(/^[^:]+::([^:]+)::\d+$/);
-            return match && match[1] === importedExport.name;
-          })
-          .sort((a, b) => {
-            // Sort by the index part (last ::N)
-            const indexA = parseInt(a.split('::').pop() || '0');
-            const indexB = parseInt(b.split('::').pop() || '0');
-            return indexA - indexB;
-          })
+    // Match keys that start with the hook name (e.g., "useFetcher" matches "useFetcher<User>()")
+    const callSignatureKeysForHook = dataForMocks
+      ? Object.keys(dataForMocks).filter((key) => {
+          const hookBaseName = importedExport.name.split(/[<(]/)[0];
+          const keyBaseName = key.split(/[<(]/)[0];
+          return keyBaseName === hookBaseName;
+        })
       : [];
 
     // Track variable name occurrences for unique function naming
     const variableNameCounts: Record<string, number> = {};
 
-    for (let i = 0; i < importedExport.calls!.length; i++) {
+    // Use the minimum of both array lengths to handle slight mismatches
+    // (e.g., stale data from previous analysis runs)
+    const iterationLimit = Math.min(
+      baseHookCalls!.length,
+      importedExport.callVariableNames!.length,
+    );
+    for (let i = 0; i < iterationLimit; i++) {
       const variableName = importedExport.callVariableNames![i];
       if (!variableName) continue;
 
@@ -916,21 +954,26 @@ function addMockToContent(
       // e.g., useFetcher_entityDiffFetcher, useFetcher_reportFetcher
       const mockFunctionName = `${importedExport.name}_${safeFunctionName}`;
 
-      // Use the canonical key at index i if available
-      const canonicalKey = canonicalKeysForHook[i];
+      // Use the call signature from baseHookCalls[i] as the data key
+      // This matches what's stored in dataForMocks
+      const callSignature = baseHookCalls![i];
 
-      // Use variable-qualified format that constructMockCode understands
-      // e.g., "entityDiffFetcher <- useFetcher" for schema lookup
-      // This generates unique variable names like useFetcher_entityDiffFetcherReturnValue
-      const qualifiedMockName = `${indexedVariableName} <- ${importedExport.name}`;
-
-      // Generate mock code using the variable-qualified name and canonical key for data lookup
+      // Generate mock code using the call signature directly
       // This prevents "symbol already declared" errors when multiple calls exist
+      // Check if this is a package import that won't have scenario copies
+      const isPackageImportForMock = importPath?.startsWith('@');
       const variableMockCode = constructMockCode(
-        qualifiedMockName, // Use variable-qualified format for unique naming
+        callSignature, // Use call signature format for data lookup
         dependencySchemas,
         importedExport.entityType,
-        canonicalKey,
+        undefined, // No need for separate canonical key
+        {
+          uniqueFunctionSuffix: safeFunctionName, // Use variable name for unique function naming
+          // For node_modules or package imports, skip spreading from __cyOriginal
+          // since those packages/files don't export *__cyOriginal variants
+          skipOriginalSpread:
+            importedExport.isNodeModule || isPackageImportForMock,
+        },
       );
 
       if (variableMockCode) {
@@ -939,7 +982,6 @@ function addMockToContent(
         // Replace the call site with the variable-specific mock function
         // e.g., useFetcher<BranchEntityDiffResult>() -> useFetcher_entityDiffFetcher()
         // e.g., useFetcher() -> useFetcher_reportFetcher()
-        const callSignature = importedExport.calls![i];
         // Escape special regex characters in the call signature
         const escapedCallSignature = callSignature.replace(
           /[.*+?^${}()|[\]\\]/g,
@@ -965,116 +1007,133 @@ function addMockToContent(
         : undefined;
 
     if (singleCallVariableName) {
-      // For single variable assignments, look up canonical key from dataForMocks
+      // For single variable assignments, use the call signature directly from dataForMocks
       const dataForMocks =
         rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
-      let canonicalKey = dataForMocks
+
+      // Find matching call signature key in dataForMocks
+      const hookBaseName = importedExport.name.split(/[<(]/)[0];
+      const callSignatureKey = dataForMocks
         ? Object.keys(dataForMocks).find((key) => {
-            // Check canonical key format: EntityName::hookName::index
-            const canonicalMatch = key.match(/^[^:]+::([^:]+)::\d+$/);
-            if (canonicalMatch && canonicalMatch[1] === importedExport.name) {
-              return true;
-            }
-            // Fall back to legacy format
-            const legacyMatch = key.match(
-              /^([a-zA-Z_][a-zA-Z0-9_]*)\s*<-\s*(.+)$/,
-            );
-            return legacyMatch && legacyMatch[2] === importedExport.name;
+            // Split on ., <, or ( to get the true base name
+            // This handles both "useFlags()" -> "useFlags" and "trpc.useUtils()" -> "trpc"
+            const keyBaseName = key.split(/[.<(]/)[0];
+            return keyBaseName === hookBaseName;
           })
         : undefined;
 
-      // If no canonical key found in dataForMocks, use variable-qualified format directly
-      // This allows constructMockCode to find the schema in dependencySchemas
-      if (!canonicalKey) {
-        canonicalKey = `${singleCallVariableName} <- ${importedExport.name}`;
-      }
+      // Use the call signature if found, otherwise construct it
+      const dataKey =
+        callSignatureKey ??
+        importedExport.calls?.[0] ??
+        `${importedExport.name}()`;
+
+      // IMPORTANT: If the dataKey is a method chain (e.g., "trpc.useUtils()"), we should
+      // use the base name (e.g., "trpc") when calling constructMockCode. This ensures
+      // constructMockCode generates a complete nested mock from the schema without
+      // referencing __cyOriginal variables.
+      const dataKeyBaseName = dataKey.split(/[.<(]/)[0];
+      const isMethodChainDataKey =
+        dataKeyBaseName === importedExport.name &&
+        dataKey !== importedExport.name &&
+        dataKey.includes('.');
+      const mockNameToUse = isMethodChainDataKey
+        ? importedExport.name
+        : dataKey;
 
       // Keep the original function name since there's only one call
+      // Check if this is a package import that won't have scenario copies
+      const isPackageImportForSingleCall = importPath?.startsWith('@');
       mockCode = constructMockCode(
-        importedExport.name,
+        mockNameToUse,
         dependencySchemas,
         importedExport.entityType,
-        canonicalKey,
-        { keepOriginalFunctionName: true },
+        undefined,
+        {
+          keepOriginalFunctionName: true,
+          // For node_modules or package imports, skip spreading from __cyOriginal
+          // since those packages/files don't export *__cyOriginal variants
+          skipOriginalSpread:
+            importedExport.isNodeModule || isPackageImportForSingleCall,
+        },
       );
       // If constructMockCode didn't generate code, fall back to simple return
+      // IMPORTANT: We inline scenarios().data() inside the function rather than
+      // storing in a const - see comment in constructMockCode.ts for why.
       if (!mockCode) {
-        mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${canonicalKey}"];
-
-function ${importedExport.name}() {
-  return ${importedExport.name}ReturnValue;
+        mockCode = `function ${importedExport.name}(...args) {
+  return scenarios().data()?.["${dataKey}"];
 }`;
       }
     } else {
-      // Look for canonical key (format: EntityName::hookName::index) or legacy variable-qualified key
-      let canonicalKey: string | undefined;
-
-      // Helper to find matching key from dataForMocks
+      // Helper to find matching call signature key from dataForMocks
+      const hookBaseName = importedExport.name.split(/[<(]/)[0];
       const findMatchingKey = (
         dataForMocks: Record<string, unknown> | undefined,
       ): string | undefined => {
         if (!dataForMocks) return undefined;
         return Object.keys(dataForMocks).find((key) => {
-          // Check canonical key format: EntityName::hookName::index
-          const canonicalMatch = key.match(/^[^:]+::([^:]+)::\d+$/);
-          if (canonicalMatch && canonicalMatch[1] === importedExport.name) {
-            return true;
-          }
-          // Fall back to legacy variable-qualified format: variableName <- functionName
-          const legacyMatch = key.match(
-            /^([a-zA-Z_][a-zA-Z0-9_]*)\s*<-\s*(.+)$/,
-          );
-          return legacyMatch && legacyMatch[2] === importedExport.name;
+          // Split on ., <, or ( to get the true base name
+          // This handles both "useFlags()" -> "useFlags" and "trpc.useUtils()" -> "trpc"
+          const keyBaseName = key.split(/[.<(]/)[0];
+          return keyBaseName === hookBaseName;
         });
       };
 
-      // CRITICAL: Check rootAnalysis FIRST for canonical keys.
-      // This ensures we use the same keys that will be in the mock DATA.
+      // Check rootAnalysis FIRST for matching keys.
       // The mock DATA is generated from rootAnalysis, so the mock CODE must
       // also use rootAnalysis keys to ensure the lookup succeeds.
-      // Bug scenario (if we check fileAnalyses first):
-      //   - Child component's fileAnalysis has: "ChildComponent::hook::0"
-      //   - Root's dataForMocks has: "RootEntity::hook::0"
-      //   - Mock CODE uses child key, but mock DATA has root key → lookup fails
-      canonicalKey = findMatchingKey(
+      let dataKey = findMatchingKey(
         rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks,
       );
 
       // If not found in rootAnalysis, fall back to fileAnalyses
-      if (!canonicalKey) {
+      if (!dataKey) {
         for (const analysis of fileAnalyses) {
-          canonicalKey = findMatchingKey(
+          dataKey = findMatchingKey(
             analysis.metadata?.scenariosDataStructure?.dataForMocks,
           );
-          if (canonicalKey) break;
+          if (dataKey) break;
         }
       }
 
-      if (canonicalKey) {
-        // Use the canonical key for data lookup
-        // Keep the original function name since there's only one call
-        mockCode = constructMockCode(
-          importedExport.name,
-          dependencySchemas,
-          importedExport.entityType,
-          canonicalKey,
-          { keepOriginalFunctionName: true },
-        );
-        // If constructMockCode didn't generate code, fall back to simple return
-        if (!mockCode) {
-          mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${canonicalKey}"];
+      // Use the data key if found, otherwise use call signature or function name.
+      // IMPORTANT: If the dataKey is a method chain (e.g., "trpc.useUtils()"), we should
+      // use the base name (e.g., "trpc") when calling constructMockCode. This ensures
+      // constructMockCode generates a complete nested mock from the schema without
+      // referencing __cyOriginal variables. The __cyOriginal pattern is only needed
+      // for partial mocking where we preserve some original methods, not for complete
+      // method-chain mocks where we provide all implementations.
+      const dataKeyBaseName = dataKey?.split(/[.<(]/)[0];
+      const isMethodChainDataKey =
+        dataKey &&
+        dataKeyBaseName === importedExport.name &&
+        dataKey !== importedExport.name &&
+        dataKey.includes('.');
+      const mockNameToUse = isMethodChainDataKey
+        ? importedExport.name
+        : (dataKey ?? importedExport.calls?.[0] ?? `${importedExport.name}()`);
 
-function ${importedExport.name}() {
-  return ${importedExport.name}ReturnValue;
+      mockCode = constructMockCode(
+        mockNameToUse,
+        dependencySchemas,
+        importedExport.entityType,
+        undefined,
+        {
+          keepOriginalFunctionName: true,
+          // For node_modules or package imports, skip spreading from __cyOriginal
+          // since those packages/files don't export *__cyOriginal variants
+          skipOriginalSpread:
+            importedExport.isNodeModule || importPath?.startsWith('@'),
+        },
+      );
+      // If constructMockCode didn't generate code, fall back to simple return
+      // IMPORTANT: We inline scenarios().data() inside the function rather than
+      // storing in a const - see comment in constructMockCode.ts for why.
+      if (!mockCode && dataKey) {
+        mockCode = `function ${importedExport.name}(...args) {
+  return scenarios().data()?.["${dataKey}"];
 }`;
-        }
-      } else {
-        // Original behavior for calls without variable names
-        mockCode = constructMockCode(
-          importedExport.name,
-          dependencySchemas,
-          importedExport.entityType,
-        );
       }
     }
   }
@@ -1105,12 +1164,39 @@ function ${importedExport.name}() {
         /[.*+?^${}()|[\]\\]/g,
         '\\$&',
       );
+      // Use a simpler, more robust regex pattern that matches the fallback path.
+      // Key improvements:
+      // 1. Uses escapeRegExp(firstPart) to handle special characters in function names
+      // 2. Uses word boundaries (\b) to prevent partial matches
+      // 3. Handles comma BEFORE or AFTER the name: (?:,\s*|\s*,)?
+      // 4. Matches specific import path (escapedImportPath)
       const importRegExp = new RegExp(
-        `(import(?:(?!${firstPart}|from|import)[\\s\\S])*?)${firstPart}(?:,\\s*)?((?:(?!import)[\\s\\S])*?from\\s+['"]${escapedImportPath}['"])`,
+        `(import\\s*\\{[^}]*?)\\b${escapeRegExp(firstPart)}\\b(?:,\\s*|\\s*,)?((?:[^}]*\\}\\s*from\\s*['"]${escapedImportPath}['"];?))`,
         'm',
       );
 
-      if (importedExportNameParts.length > 1) {
+      // Check if any call signature has multiple parts (e.g., "logger.error(error)")
+      // If so, the mock code will spread from __cyOriginal, so we need to rename the import
+      // EXCEPT:
+      // 1. For node_module imports, the __cyOriginal pattern doesn't work because
+      //    the original package doesn't export *__cyOriginal variants.
+      // 2. For package imports (starting with @), the __cyOriginal pattern doesn't work
+      //    because scenario copies aren't created for package files - they keep the
+      //    original import path which doesn't export *__cyOriginal.
+      const anyCallHasMultipleParts = importedExport.calls?.some((call) => {
+        const callParts = splitOutsideParenthesesAndArrays(call);
+        return callParts.length > 1;
+      });
+
+      // Package imports (starting with @) don't get scenario copies, so __cyOriginal won't exist
+      const isPackageImport = importPath.startsWith('@');
+
+      const shouldRenameToOriginal =
+        !importedExport.isNodeModule &&
+        !isPackageImport &&
+        (importedExportNameParts.length > 1 || anyCallHasMultipleParts);
+
+      if (shouldRenameToOriginal) {
         fileContent = fileContent.replace(
           importRegExp,
           `$1${firstPart}__cyOriginal$2`,
@@ -1119,6 +1205,21 @@ function ${importedExport.name}() {
         fileContent = fileContent.replace(importRegExp, '$1$2');
       }
 
+      // Also handle namespace imports (import * as foo from '...')
+      // These need to be renamed to foo__cyOriginal when the mock code spreads from the original.
+      // Note: We match any path (not just escapedImportPath) because the import path may have
+      // been rewritten by transitive import handling before this code runs.
+      if (shouldRenameToOriginal) {
+        const namespaceImportRegExp = new RegExp(
+          `(import\\s+\\*\\s+as\\s+)${escapeRegExp(firstPart)}(\\s+from\\s+['"][^'"]*['"])`,
+          'm',
+        );
+        fileContent = fileContent.replace(
+          namespaceImportRegExp,
+          `$1${firstPart}__cyOriginal$2`,
+        );
+      }
+
       // Remove empty imports entirely to avoid partial commenting issues with multiline imports
       // This handles both single-line and multiline empty imports
       fileContent = fileContent.replace(
@@ -1143,7 +1244,20 @@ function ${importedExport.name}() {
       'm',
     );
 
-    if (importedExportNameParts.length > 1) {
+    // Check if any call signature has multiple parts (e.g., "logger.error(error)")
+    // If so, the mock code will spread from __cyOriginal, so we need to rename the import
+    // EXCEPT: For node_module imports, the __cyOriginal pattern doesn't work because
+    // the original package doesn't export *__cyOriginal variants.
+    const anyCallHasMultipleParts = importedExport.calls?.some((call) => {
+      const callParts = splitOutsideParenthesesAndArrays(call);
+      return callParts.length > 1;
+    });
+
+    const shouldRenameToOriginal =
+      !importedExport.isNodeModule &&
+      (importedExportNameParts.length > 1 || anyCallHasMultipleParts);
+
+    if (shouldRenameToOriginal) {
       // Rename the import instead of removing (for destructured access patterns)
       fileContent = fileContent.replace(
         namedImportRegExp,
@@ -1599,9 +1713,16 @@ export default async function writeScenarioComponents({
   });
 
   let importedExportIndex = 0;
+  const loopStartTime = Date.now();
+  console.log(
+    `[WriteScenario] Starting import loop for ${entity.name}: ${sortedImportedExports.length} imports`,
+  );
   for (const importedExport of sortedImportedExports) {
     importedExportIndex++;
     if (importedExportIndex % 5 === 0 || importedExportIndex === 1) {
+      console.log(
+        `[WriteScenario] ${entity.name} import ${importedExportIndex}/${sortedImportedExports.length}: ${importedExport.name} elapsed=${Date.now() - loopStartTime}ms`,
+      );
       debugLog(
         `Processing importedExport ${importedExportIndex}/${sortedImportedExports.length}`,
         {
@@ -1789,6 +1910,10 @@ export default async function writeScenarioComponents({
               importedExport.resolvedIsDefault === true &&
               importedExport.isDefault === false;
 
+            console.log(
+              `[WriteScenario] RECURSE START: ${entity.name} -> ${importedExportEntity.name}`,
+            );
+            const recurseStartTime = Date.now();
             debugLog(
               `Recursing into writeScenarioComponents for ${importedExportEntity.name}`,
               {
@@ -1820,7 +1945,10 @@ export default async function writeScenarioComponents({
                   ? importedExport.name
                   : undefined,
               }),
-              60000, // 1 minute timeout for recursive calls
+              180000, // 3 minute timeout for recursive calls (complex components need more time)
+            );
+            console.log(
+              `[WriteScenario] RECURSE END: ${entity.name} -> ${importedExportEntity.name} took ${Date.now() - recurseStartTime}ms`,
             );
             debugLog(
               `Completed recursive writeScenarioComponents for ${importedExportEntity.name}`,
@@ -2162,6 +2290,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     }
   }
 
+  // Track post-import-loop timing
+  const postLoopStartTime = Date.now();
+  console.log(`[WriteScenario] POST-LOOP START: ${entity.name}`);
+
   // Collect universal mocks BEFORE processing nodeModuleImports
   // This is needed to check if a node module import is handled by a universal mock
   const universalMocks = project.metadata?.universalMocks ?? [];
@@ -2221,6 +2353,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     );
   }
 
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: node+universal mocks took ${Date.now() - postLoopStartTime}ms`,
+  );
+
   if (
     rootAnalysis.entitySha === entity.sha &&
     entity.metadata?.notExported &&
@@ -2299,6 +2435,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
   );
   debugLog('Completed rewriteRelativeModuleImports');
 
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: transformations took ${Date.now() - postLoopStartTime}ms`,
+  );
+
   /**
    * Recursively process a file's imports to create transitive copies with server-only stripped.
    * This handles chains of arbitrary depth: A -> B -> C -> D where each needs server-only removed.
@@ -2319,7 +2459,7 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     startTime: number = Date.now(),
   ): Promise<string> {
     // Global timeout for entire transitive processing
-    const GLOBAL_TIMEOUT_MS = 60000; // 1 minute max for all transitive processing
+    const GLOBAL_TIMEOUT_MS = 180000; // 3 minutes max for all transitive processing (complex components need more time)
     const elapsed = Date.now() - startTime;
     if (elapsed > GLOBAL_TIMEOUT_MS) {
       throw new Error(
@@ -2328,6 +2468,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     }
 
     const importPaths = extractInternalImportPaths(content);
+    // Always log to help debug timeout issues
+    console.log(
+      `[TransitiveImports] depth=${depth} file=${path.basename(sourceFilePath)} imports=${importPaths.length} visited=${visitedPaths.size} elapsed=${Date.now() - startTime}ms`,
+    );
     debugLog(`processTransitiveImportsRecursively depth=${depth}`, {
       sourceFilePath,
       importCount: importPaths.length,
@@ -2382,8 +2526,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
       );
       const extension = importFile.name.split('.').pop();
       const isIndex = isIndexPath(importFile.path);
-      const pathHash = safeFileName(importFile.path);
-      const transitiveFilePath = `${PROJECT_RELATIVE_PATH}/${basePath}/${pathHash}_${isIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${extension}`;
+      // Limit pathHash length to prevent ENAMETOOLONG errors on macOS (255 char limit)
+      const pathHash = safeFileName(importFile.path, { maxLength: 80 });
+      const scenarioSlug = safeFileName(scenario.name, { maxLength: 60 });
+      const transitiveFilePath = `${PROJECT_RELATIVE_PATH}/${basePath}/${pathHash}_${isIndex ? 'index_' : ''}transitive_${scenarioSlug}.${extension}`;
 
       // Check if this is a circular import (we're already processing this file)
       const isCircularImport = visitedPaths.has(resolvedPath);
@@ -2507,6 +2653,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     return modifiedContent;
   }
 
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: before remaining imports ${Date.now() - postLoopStartTime}ms`,
+  );
+
   // Process remaining internal imports that weren't in importedExports
   // This handles transitive dependencies: when the file content includes code (e.g., from
   // other functions in the same file) that imports from files with "server-only"
@@ -2582,8 +2732,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     );
     const targetFileExtension = targetFile.name.split('.').pop();
     const targetFileIsIndex = isIndexPath(targetFile.path);
-    const filePathHash = safeFileName(targetFile.path);
-    const transformedFilePath = `${PROJECT_RELATIVE_PATH}/${targetFileBasePath}/${filePathHash}_${targetFileIsIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${targetFileExtension}`;
+    // Limit path hash length to prevent ENAMETOOLONG errors
+    const filePathHash = safeFileName(targetFile.path, { maxLength: 80 });
+    const targetScenarioSlug = safeFileName(scenario.name, { maxLength: 60 });
+    const transformedFilePath = `${PROJECT_RELATIVE_PATH}/${targetFileBasePath}/${filePathHash}_${targetFileIsIndex ? 'index_' : ''}transitive_${targetScenarioSlug}.${targetFileExtension}`;
 
     // Check if we've already processed this file as a transitive copy
     // Note: __data_file_written__ is for entity-specific scenario files with different naming,
@@ -2638,8 +2790,12 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
         );
         const nestedExtension = nestedFile.name.split('.').pop();
         const nestedIsIndex = isIndexPath(nestedFile.path);
-        const nestedPathHash = safeFileName(nestedFile.path);
-        const nestedTransformedPath = `${PROJECT_RELATIVE_PATH}/${nestedBasePath}/${nestedPathHash}_${nestedIsIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${nestedExtension}`;
+        // Limit path hash length to prevent ENAMETOOLONG errors
+        const nestedPathHash = safeFileName(nestedFile.path, { maxLength: 80 });
+        const nestedScenarioSlug = safeFileName(scenario.name, {
+          maxLength: 60,
+        });
+        const nestedTransformedPath = `${PROJECT_RELATIVE_PATH}/${nestedBasePath}/${nestedPathHash}_${nestedIsIndex ? 'index_' : ''}transitive_${nestedScenarioSlug}.${nestedExtension}`;
 
         // Check if already processed as a transitive file (we can rewrite to point to it)
         // Note: __data_file_written__ is for entity-specific scenario files with different naming,
@@ -2760,6 +2916,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     fileContent = fileContent.replace(importRegex, `$1${safeRelativePath}$2`);
   }
 
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: remaining imports loop took ${Date.now() - postLoopStartTime}ms`,
+  );
+
   const scenarioComponentComment = `// This file is auto-generated by CodeYam. Do not edit this file manually.
 // This file contains content for a scenario component:
 // Analyses being written: ${JSON.stringify(fileAnalyses?.map((a) => ({ id: a.id, entityName: a.entityName })))}
@@ -2771,6 +2931,34 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
 // Scenario: ${scenario.id} - ${scenario.name}
 `;
 
+  // Final pass: Rename any namespace imports (import * as X from '...') that have
+  // corresponding mock code using ...X__cyOriginal spread pattern.
+  // This handles cases where:
+  // 1. The import path was rewritten by transitive import handling
+  // 2. The import wasn't caught by the earlier renaming logic
+  // We scan for all __cyOriginal references in the mock code and ensure the imports are renamed.
+  const cyOriginalReferences = fileContent.match(/\.\.\.(\w+)__cyOriginal/g);
+  if (cyOriginalReferences) {
+    const uniqueNames = [
+      ...new Set(
+        cyOriginalReferences.map((ref) =>
+          ref.replace('...', '').replace('__cyOriginal', ''),
+        ),
+      ),
+    ];
+    for (const name of uniqueNames) {
+      // Match namespace imports for this name that haven't been renamed yet
+      const namespaceImportRegex = new RegExp(
+        `(import\\s+\\*\\s+as\\s+)${escapeRegExp(name)}(\\s+from\\s+['"][^'"]*['"])`,
+        'g',
+      );
+      fileContent = fileContent.replace(
+        namespaceImportRegex,
+        `$1${name}__cyOriginal$2`,
+      );
+    }
+  }
+
   // Use the directive that was extracted at the beginning of processing
   // This ensures it stays at the very top even after imports are prepended
   // NOTE: We only preserve "use client" directives, NOT "use server" directives.
@@ -2792,5 +2980,9 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
   debugLog('Successfully wrote scenario file');
   scenarioComponentPaths.push(scenarioComponentPath);
 
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: COMPLETE total=${Date.now() - postLoopStartTime}ms`,
+  );
+
   return { scenarioComponentPaths, writtenScenarioComponents };
 }