@codeyam/codeyam-cli 0.1.0-staging.dd216e0 → 0.1.0-staging.e090cb3

package/background/src/lib/virtualized/project/writeScenarioComponents.js

@@ -62,7 +62,10 @@ function resetDebugTiming() {
  */
 function findEndOfImports(content) {
     try {
-        const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
+        // 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.tsx', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
         let lastImportEnd = 0;
         // Visit all top-level statements to find import/export declarations
         for (const statement of sourceFile.statements) {
@@ -476,7 +479,8 @@ function extractInternalImportPaths(fileContent) {
 function extractInternalImportPathsAst(fileContent) {
     const importPaths = [];
     try {
-        const sourceFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.Latest, true);
+        // Use temp.tsx to enable JSX parsing for consistent handling of JSX files
+        const sourceFile = ts.createSourceFile('temp.tsx', fileContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
         for (const statement of sourceFile.statements) {
             if (ts.isImportDeclaration(statement) && statement.moduleSpecifier) {
                 const moduleSpecifier = statement.moduleSpecifier;
@@ -592,46 +596,106 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
     }
     // Check if we have multiple calls with different variable names
     // This requires generating separate mock functions for each call site
-    const hasMultipleCallsWithVariables = importedExport.calls &&
-        importedExport.calls.length > 1 &&
+    //
+    // 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 = 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;
     const variableMockCodes = [];
     if (hasMultipleCallsWithVariables) {
         // Generate separate mock functions for each variable-qualified call
-        // Track variable name occurrences to disambiguate when same variable is reused
-        // (mirrors the logic in gatherDataForMocks)
+        // Look up canonical keys from dataForMocks and track variable names for function naming
+        // Get all call signature keys for this hook from dataForMocks
+        const dataForMocks = rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
+        // 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 = {};
-        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;
             // Calculate the occurrence index for this variable name
             const occurrence = variableNameCounts[variableName] ?? 0;
             variableNameCounts[variableName] = occurrence + 1;
-            // If this is a reused variable name (occurrence > 0), append index
-            // e.g., "fetcher[1] <- useFetcher" for the second usage of "fetcher"
+            // Build indexed variable name for function naming
             const indexedVariableName = occurrence > 0 ? `${variableName}[${occurrence}]` : variableName;
-            // Generate mock code for this specific call using variable-qualified name
-            // Format: "variableName <- functionName" (reads as "variableName receives from functionName")
-            const qualifiedName = `${indexedVariableName} <- ${importedExport.name}`;
-            const variableMockCode = constructMockCode(qualifiedName, dependencySchemas, importedExport.entityType);
+            // Use safe function name with underscores instead of brackets
+            // e.g., fetcher[1] -> fetcher_1
+            const safeFunctionName = indexedVariableName.replace(/\[(\d+)\]/g, '_$1');
+            // Compute unique mock function name for call site replacement
+            // e.g., useFetcher_entityDiffFetcher, useFetcher_reportFetcher
+            const mockFunctionName = `${importedExport.name}_${safeFunctionName}`;
+            // Use the call signature from baseHookCalls[i] as the data key
+            // This matches what's stored in dataForMocks
+            const callSignature = baseHookCalls[i];
+            // 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(callSignature, // Use call signature format for data lookup
+            dependencySchemas, importedExport.entityType, 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) {
                 variableMockCodes.push(variableMockCode);
                 // Replace the call site with the variable-specific mock function
                 // e.g., useFetcher<BranchEntityDiffResult>() -> useFetcher_entityDiffFetcher()
                 // e.g., useFetcher() -> useFetcher_reportFetcher()
-                // For indexed variables: useFetcher() -> useFetcher_fetcher_1()
-                const callSignature = importedExport.calls[i];
                 // Escape special regex characters in the call signature
                 const escapedCallSignature = callSignature.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                // Create regex that matches the call (with optional whitespace variations)
-                const callRegex = new RegExp(escapedCallSignature.replace(/\s+/g, '\\s*'), 'g');
-                // Use safe function name with underscores instead of brackets
-                // e.g., fetcher[1] -> fetcher_1
-                const safeFunctionName = indexedVariableName.replace(/\[(\d+)\]/g, '_$1');
-                const mockFunctionName = `${importedExport.name}_${safeFunctionName}`;
+                // Create regex that matches the call (with optional whitespace variations).
+                // TypeScript formatters commonly break type parameters across lines, e.g.:
+                //   useLoaderData<
+                //     typeof loader
+                //   >()
+                // So we allow optional whitespace around < and > delimiters, not just
+                // where whitespace already exists in the call signature string.
+                const callRegex = new RegExp(escapedCallSignature
+                    .replace(/\s+/g, '\\s*')
+                    .replace(/</g, '\\s*<\\s*')
+                    .replace(/>/g, '\\s*>\\s*'), 'gs');
                 fileContent = fileContent.replace(callRegex, `${mockFunctionName}()`);
             }
         }
@@ -646,66 +710,140 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
             ? importedExport.callVariableNames[0]
             : undefined;
         if (singleCallVariableName) {
-            // For single variable assignments, use the variable-qualified key for data lookup
-            // Use constructMockCode to generate proper dispatch functions for nested function calls
-            // (e.g., useTranslation returns { t } where t() needs to dispatch based on translation key)
-            const qualifiedKey = `${singleCallVariableName} <- ${importedExport.name}`;
-            // Keep the original function name since there's only one call - no need for unique names
-            mockCode = constructMockCode(qualifiedKey, dependencySchemas, importedExport.entityType, { keepOriginalFunctionName: true });
+            // For single variable assignments, use the call signature directly from dataForMocks
+            const dataForMocks = rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
+            // Find matching call signature key in dataForMocks
+            // IMPORTANT: First try exact match with type parameters (e.g., "useLoaderData<LoaderData>()")
+            // to avoid picking the wrong variant (e.g., "useLoaderData<typeof loader>()" which may
+            // have different properties). Fall back to base name matching only if exact match fails.
+            const hookBaseName = importedExport.name.split(/[<(]/)[0];
+            const expectedKey = importedExport.calls?.[0];
+            let callSignatureKey;
+            if (dataForMocks) {
+                const keys = Object.keys(dataForMocks);
+                // First try exact match with the expected call signature
+                if (expectedKey && keys.includes(expectedKey)) {
+                    callSignatureKey = expectedKey;
+                }
+                else {
+                    // Fall back to base name matching
+                    callSignatureKey = keys.find((key) => {
+                        // 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;
+                    });
+                }
+            }
+            // 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(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 || 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()?.["${qualifiedKey}"];
-
-function ${importedExport.name}() {
-  return ${importedExport.name}ReturnValue;
+                mockCode = `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)
+const _${importedExport.name}Ref = {
+  current: null,
+};
+function ${importedExport.name}(...args) {
+  if (!_${importedExport.name}Ref.current) {
+    _${importedExport.name}Ref.current = scenarios().data()?.["${dataKey}"];
+  }
+  return _${importedExport.name}Ref.current;
 }`;
             }
         }
         else {
-            // Check if any analysis (fileAnalyses or rootAnalysis) has this function's data
-            // under a variable-qualified key. The entity that CALLS the function (e.g., FileTableRow)
-            // has the dataForMocks with the variable-qualified key, not the root analysis (e.g., GitView).
-            let variableQualifiedKey;
-            // First check fileAnalyses (the analyses for the entity being written)
-            for (const analysis of fileAnalyses) {
-                const dataForMocks = analysis.metadata?.scenariosDataStructure?.dataForMocks;
-                if (dataForMocks) {
-                    variableQualifiedKey = Object.keys(dataForMocks).find((key) => {
-                        const match = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*<-\s*(.+)$/);
-                        return match && match[2] === importedExport.name;
-                    });
-                    if (variableQualifiedKey) {
-                        break;
-                    }
+            // Helper to find matching call signature key from dataForMocks
+            // IMPORTANT: First try exact match with type parameters (e.g., "useLoaderData<LoaderData>()")
+            // to avoid picking the wrong variant. Fall back to base name matching only if needed.
+            const hookBaseName = importedExport.name.split(/[<(]/)[0];
+            const expectedKey = importedExport.calls?.[0];
+            const findMatchingKey = (dataForMocks) => {
+                if (!dataForMocks)
+                    return undefined;
+                const keys = Object.keys(dataForMocks);
+                // First try exact match with the expected call signature
+                if (expectedKey && keys.includes(expectedKey)) {
+                    return expectedKey;
                 }
-            }
-            // If not found in fileAnalyses, fall back to rootAnalysis
-            if (!variableQualifiedKey) {
-                const dataForMocks = rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
-                if (dataForMocks) {
-                    variableQualifiedKey = Object.keys(dataForMocks).find((key) => {
-                        const match = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*<-\s*(.+)$/);
-                        return match && match[2] === importedExport.name;
-                    });
+                // Fall back to base name matching
+                return keys.find((key) => {
+                    // 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;
+                });
+            };
+            // 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.
+            let dataKey = findMatchingKey(rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks);
+            // If not found in rootAnalysis, fall back to fileAnalyses
+            if (!dataKey) {
+                for (const analysis of fileAnalyses) {
+                    dataKey = findMatchingKey(analysis.metadata?.scenariosDataStructure?.dataForMocks);
+                    if (dataKey)
+                        break;
                 }
             }
-            if (variableQualifiedKey) {
-                // Use the variable-qualified key found in the analysis
-                // Use constructMockCode to generate proper dispatch functions for nested function calls
-                // Keep the original function name since there's only one call - no need for unique names
-                mockCode = constructMockCode(variableQualifiedKey, dependencySchemas, importedExport.entityType, { keepOriginalFunctionName: true });
-                // If constructMockCode didn't generate code, fall back to simple return
-                if (!mockCode) {
-                    mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${variableQualifiedKey}"];
-
-function ${importedExport.name}() {
-  return ${importedExport.name}ReturnValue;
+            // 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}()`);
+            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 = `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)
+const _${importedExport.name}Ref = {
+  current: null,
+};
+function ${importedExport.name}(...args) {
+  if (!_${importedExport.name}Ref.current) {
+    _${importedExport.name}Ref.current = scenarios().data()?.["${dataKey}"];
+  }
+  return _${importedExport.name}Ref.current;
 }`;
-                }
-            }
-            else {
-                // Original behavior for calls without variable names
-                mockCode = constructMockCode(importedExport.name, dependencySchemas, importedExport.entityType);
             }
         }
     }
@@ -724,13 +862,44 @@ function ${importedExport.name}() {
         else {
             // Escape regex special characters in importPath (e.g., brackets in [environmentId])
             const escapedImportPath = importPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const importRegExp = new RegExp(`(import(?:(?!${firstPart}|from|import)[\\s\\S])*?)${firstPart}(?:,\\s*)?((?:(?!import)[\\s\\S])*?from\\s+['"]${escapedImportPath}['"])`, 'm');
-            if (importedExportNameParts.length > 1) {
+            // 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\\s*\\{[^}]*?)\\b${escapeRegExp(firstPart)}\\b(?:,\\s*|\\s*,)?((?:[^}]*\\}\\s*from\\s*['"]${escapedImportPath}['"];?))`, 'm');
+            // 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`);
             }
             else {
                 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(/import\s*\{\s*\}\s*from\s+['"][^'"]*['"];?\s*\n?/g, '');
@@ -746,7 +915,17 @@ function ${importedExport.name}() {
         // This handles imports like: import { useEnvironment, otherThing } from "any/path"
         // Removes useEnvironment but keeps otherThing
         const namedImportRegExp = new RegExp(`(import\\s*\\{[^}]*?)\\b${escapeRegExp(firstPart)}\\b(?:,\\s*|\\s*,)?((?:[^}]*\\}\\s*from\\s*['"][^'"]*['"];?))`, '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, `$1${firstPart}__cyOriginal$2`);
         }
@@ -1079,9 +1258,12 @@ export default async function writeScenarioComponents({ project, file, entity, r
         fileContentLength: fileContent.length,
     });
     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}`, {
                 name: importedExport.name,
                 filePath: importedExport.filePath,
@@ -1214,6 +1396,8 @@ export default async function writeScenarioComponents({ project, file, entity, r
                         // e.g., if file has `export default X` but parent does `import { X } from '...'`
                         const needsNamedReExport = 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}`, {
                             entityName: importedExportEntity.name,
                             filePath: fileNotMocked.path,
@@ -1236,7 +1420,8 @@ export default async function writeScenarioComponents({ project, file, entity, r
                             exportAsNamed: needsNamedReExport
                                 ? importedExport.name
                                 : undefined,
-                        }), 60000);
+                        }), 180000);
+                        console.log(`[WriteScenario] RECURSE END: ${entity.name} -> ${importedExportEntity.name} took ${Date.now() - recurseStartTime}ms`);
                         debugLog(`Completed recursive writeScenarioComponents for ${importedExportEntity.name}`);
                         writtenScenarioComponents = updatedWrittenScenarioComponents;
                         scenarioComponentPaths.push(...newScenarioComponentPaths);
@@ -1498,6 +1683,9 @@ ${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 ?? [];
@@ -1531,6 +1719,7 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
         const importRegex = new RegExp(`(import\\s+(?:\\{[^}]*\\}|\\*\\s+as\\s+\\w+|\\w+)\\s+from\\s+)['"]${originalPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`, 'g');
         fileContent = fileContent.replace(importRegex, `$1'${mockFileRelativePath}'`);
     }
+    console.log(`[WriteScenario] POST-LOOP ${entity.name}: node+universal mocks took ${Date.now() - postLoopStartTime}ms`);
     if (rootAnalysis.entitySha === entity.sha &&
         entity.metadata?.notExported &&
         entity.name !== 'default') {
@@ -1590,6 +1779,7 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     debugLog('Starting rewriteRelativeModuleImports');
     fileContent = rewriteRelativeModuleImports(fileContent, `${PROJECT_RELATIVE_PATH}/${file.path}`, scenarioComponentPath);
     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.
@@ -1603,12 +1793,14 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
      */
     async function processTransitiveImportsRecursively(content, sourceFilePath, targetFilePath, visitedPaths = new Set(), depth = 0, startTime = Date.now()) {
         // 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(`processTransitiveImportsRecursively exceeded ${GLOBAL_TIMEOUT_MS}ms (elapsed: ${elapsed}ms) at depth=${depth} for ${sourceFilePath}`);
         }
         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,
@@ -1645,8 +1837,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
             const basePath = safeFolder(importFile.path.split('/').slice(0, -1).join('/'));
             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);
             // Check if already processed
@@ -1724,6 +1918,7 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
         debugLog(`Returning from processTransitiveImportsRecursively depth=${depth}`);
         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"
@@ -1781,8 +1976,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
         const targetFileBasePath = safeFolder(targetFile.path.split('/').slice(0, -1).join('/'));
         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,
         // but we still need transitive copies for server-only stripping. Data entity files may
@@ -1821,8 +2018,12 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
                 const nestedBasePath = safeFolder(nestedFile.path.split('/').slice(0, -1).join('/'));
                 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,
                 // but we still need transitive copies for server-only stripping in the import chain
@@ -1888,6 +2089,7 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
         const importRegex = new RegExp(`(from\\s*["'])${escapedImportPath}(["'])`, 'g');
         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 })))}
@@ -1898,6 +2100,23 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
 // Entity: ${rootAnalysis.entitySha} ${rootAnalysis.entityName}
 // 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.
@@ -1918,6 +2137,7 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     await writeFile(scenarioComponentPath, finalContent);
     debugLog('Successfully wrote scenario file');
     scenarioComponentPaths.push(scenarioComponentPath);
+    console.log(`[WriteScenario] POST-LOOP ${entity.name}: COMPLETE total=${Date.now() - postLoopStartTime}ms`);
     return { scenarioComponentPaths, writtenScenarioComponents };
 }
 //# sourceMappingURL=writeScenarioComponents.js.map