@codeyam/codeyam-cli 0.1.0-staging.596f0eb → 0.1.0-staging.76566f9

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

@@ -8,6 +8,51 @@ import * as fs from 'fs';
 import * as path from 'path';
 import ts from 'typescript';
 import { applyServerOnlyMocks } from "./serverOnlyModules.js";
+// Debug timing helper for tracking where time is spent
+const DEBUG_TIMING = process.env.DEBUG_WRITE_SCENARIO === 'true';
+let debugStartTime;
+let debugLastTime;
+// Timeout protection to prevent infinite hangs
+const WRITE_SCENARIO_TIMEOUT_MS = parseInt(process.env.WRITE_SCENARIO_TIMEOUT_MS || '300000', // Default 5 minutes
+10);
+class WriteScenarioTimeoutError extends Error {
+    constructor(operation, timeoutMs) {
+        super(`WriteScenarioComponents timed out after ${timeoutMs}ms during: ${operation}`);
+        this.name = 'WriteScenarioTimeoutError';
+    }
+}
+async function withTimeout(operation, promise, timeoutMs = WRITE_SCENARIO_TIMEOUT_MS) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new WriteScenarioTimeoutError(operation, timeoutMs));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    }
+}
+function debugLog(message, extra) {
+    if (!DEBUG_TIMING)
+        return;
+    const now = Date.now();
+    if (!debugStartTime) {
+        debugStartTime = now;
+        debugLastTime = now;
+    }
+    const elapsed = now - debugStartTime;
+    const delta = now - debugLastTime;
+    debugLastTime = now;
+    console.log(`[WriteScenario +${elapsed}ms Δ${delta}ms] ${message}`, extra ? JSON.stringify(extra, null, 2) : '');
+}
+function resetDebugTiming() {
+    debugStartTime = 0;
+    debugLastTime = 0;
+}
 /**
  * Find the end position of the last import/export-from statement using TypeScript AST.
  * This is more reliable than regex for handling multiline imports, comments, etc.
@@ -17,7 +62,10 @@ import { applyServerOnlyMocks } from "./serverOnlyModules.js";
  */
 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) {
@@ -46,6 +94,106 @@ function findEndOfImports(content) {
 function escapeRegExp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Remove a named import from file content using TypeScript AST.
+ * Handles both regular imports (`EntityName`) and type-only imports (`type EntityName`).
+ *
+ * @param fileContent - The file content to modify
+ * @param entityName - The name of the entity to remove from imports
+ * @returns The modified file content with the entity removed from imports
+ */
+function removeNamedImportAst(fileContent, entityName) {
+    try {
+        const sourceFile = ts.createSourceFile('temp.tsx', fileContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+        const replacements = [];
+        for (const statement of sourceFile.statements) {
+            if (!ts.isImportDeclaration(statement))
+                continue;
+            if (!statement.importClause?.namedBindings)
+                continue;
+            if (!ts.isNamedImports(statement.importClause.namedBindings))
+                continue;
+            const namedImports = statement.importClause.namedBindings;
+            const elements = namedImports.elements;
+            // Find the element that matches our entity name
+            const matchingIndex = elements.findIndex((el) => el.name.text === entityName);
+            if (matchingIndex === -1)
+                continue;
+            // Check if there's a default import (e.g., `import DefaultName, { NamedImport } from '...'`)
+            const hasDefaultImport = !!statement.importClause.name;
+            // If this is the only named import AND there's no default import, remove the entire statement
+            if (elements.length === 1 && !hasDefaultImport) {
+                // Find the end including any trailing newline
+                let end = statement.getEnd();
+                const afterStatement = fileContent.slice(end);
+                const trailingNewline = afterStatement.match(/^\r?\n/);
+                if (trailingNewline) {
+                    end += trailingNewline[0].length;
+                }
+                replacements.push({
+                    start: statement.getStart(sourceFile),
+                    end,
+                    replacement: '',
+                });
+                continue;
+            }
+            // Otherwise, rebuild the import without this element
+            const remainingElements = elements.filter((_, i) => i !== matchingIndex);
+            // Get the module specifier
+            const moduleSpecifier = statement.moduleSpecifier;
+            if (!ts.isStringLiteral(moduleSpecifier))
+                continue;
+            // Preserve import type modifier if present
+            const importTypePrefix = statement.importClause.isTypeOnly ? 'type ' : '';
+            // Get the default import name if present
+            const defaultImportName = statement.importClause.name?.text;
+            let newImport;
+            if (remainingElements.length === 0) {
+                // All named imports were removed, but there's a default import to preserve
+                // (we only get here when hasDefaultImport is true, because otherwise we'd have
+                // removed the whole statement at the elements.length === 1 check above)
+                newImport = `import ${defaultImportName} from ${moduleSpecifier.getText(sourceFile)};`;
+            }
+            else {
+                // Build the new named imports string
+                const newNamedImports = remainingElements
+                    .map((el) => {
+                    const isTypeOnly = el.isTypeOnly;
+                    const name = el.name.text;
+                    const propertyName = el.propertyName?.text;
+                    if (propertyName) {
+                        return isTypeOnly
+                            ? `type ${propertyName} as ${name}`
+                            : `${propertyName} as ${name}`;
+                    }
+                    return isTypeOnly ? `type ${name}` : name;
+                })
+                    .join(', ');
+                // Build the new import statement, preserving default import if present
+                const defaultImportPrefix = defaultImportName
+                    ? `${defaultImportName}, `
+                    : '';
+                newImport = `import ${importTypePrefix}${defaultImportPrefix}{ ${newNamedImports} } from ${moduleSpecifier.getText(sourceFile)};`;
+            }
+            replacements.push({
+                start: statement.getStart(sourceFile),
+                end: statement.getEnd(),
+                replacement: newImport,
+            });
+        }
+        // Apply replacements in reverse order to preserve positions
+        let result = fileContent;
+        replacements.sort((a, b) => b.start - a.start);
+        for (const { start, end, replacement } of replacements) {
+            result = result.slice(0, start) + replacement + result.slice(end);
+        }
+        return result;
+    }
+    catch (error) {
+        console.warn('[removeNamedImportAst] Failed to parse file:', error);
+        return fileContent; // Return original content on error
+    }
+}
 /**
  * Map nested dist paths to src paths.
  * Some build tools create nested structures like:
@@ -321,22 +469,37 @@ function stripServerOnlyImport(fileContent) {
  * Excludes node_modules imports (bare specifiers like 'react', '@prisma/client').
  */
 function extractInternalImportPaths(fileContent) {
+    // Always use AST parsing - regex with nested quantifiers can cause catastrophic
+    // backtracking that hangs on a single .exec() call (before iteration limits kick in)
+    return extractInternalImportPathsAst(fileContent);
+}
+/**
+ * Extract internal import paths using TypeScript AST - more reliable for large files
+ */
+function extractInternalImportPathsAst(fileContent) {
     const importPaths = [];
-    // Match import statements with their paths
-    // Handles: import x from "path", import { x } from "path", import * as x from "path"
-    const importRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*,?\s*)*\s*from\s*["']([^"']+)["']/g;
-    let match;
-    while ((match = importRegex.exec(fileContent)) !== null) {
-        const importPath = match[1];
-        // Skip node_modules imports (bare specifiers)
-        // Internal imports start with '.', '@/', '~/' or similar path aliases
-        if (importPath.startsWith('.') ||
-            importPath.startsWith('@/') ||
-            importPath.startsWith('~/') ||
-            importPath.startsWith('#')) {
-            importPaths.push(importPath);
+    try {
+        // 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;
+                if (ts.isStringLiteral(moduleSpecifier)) {
+                    const importPath = moduleSpecifier.text;
+                    // Skip node_modules imports (bare specifiers)
+                    if (importPath.startsWith('.') ||
+                        importPath.startsWith('@/') ||
+                        importPath.startsWith('~/') ||
+                        importPath.startsWith('#')) {
+                        importPaths.push(importPath);
+                    }
+                }
+            }
         }
     }
+    catch (error) {
+        console.warn('[extractInternalImportPathsAst] Failed to parse file:', error);
+    }
     return importPaths;
 }
 /**
@@ -441,8 +604,18 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
     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++) {
             const variableName = importedExport.callVariableNames[i];
@@ -451,28 +624,31 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
             // 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 importedExport.calls[i] as the data key
+            // This matches what's stored in dataForMocks
+            const callSignature = importedExport.calls[i];
+            // Generate mock code using the call signature directly
+            // This prevents "symbol already declared" errors when multiple calls exist
+            const variableMockCode = constructMockCode(callSignature, // Use call signature format for data lookup
+            dependencySchemas, importedExport.entityType, undefined, // No need for separate canonical key
+            { uniqueFunctionSuffix: safeFunctionName });
             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}`;
                 fileContent = fileContent.replace(callRegex, `${mockFunctionName}()`);
             }
         }
@@ -487,15 +663,26 @@ 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
+            const hookBaseName = importedExport.name.split(/[<(]/)[0];
+            const callSignatureKey = dataForMocks
+                ? Object.keys(dataForMocks).find((key) => {
+                    const keyBaseName = key.split(/[<(]/)[0];
+                    return keyBaseName === hookBaseName;
+                })
+                : undefined;
+            // Use the call signature if found, otherwise construct it
+            const dataKey = callSignatureKey ??
+                importedExport.calls?.[0] ??
+                `${importedExport.name}()`;
+            // Keep the original function name since there's only one call
+            mockCode = constructMockCode(dataKey, // Use call signature format
+            dependencySchemas, importedExport.entityType, undefined, { keepOriginalFunctionName: true });
             // If constructMockCode didn't generate code, fall back to simple return
             if (!mockCode) {
-                mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${qualifiedKey}"];
+                mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${dataKey}"];
 
 function ${importedExport.name}() {
   return ${importedExport.name}ReturnValue;
@@ -503,50 +690,38 @@ function ${importedExport.name}() {
             }
         }
         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) {
+            // Helper to find matching call signature key from dataForMocks
+            const hookBaseName = importedExport.name.split(/[<(]/)[0];
+            const findMatchingKey = (dataForMocks) => {
+                if (!dataForMocks)
+                    return undefined;
+                return Object.keys(dataForMocks).find((key) => {
+                    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 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;
-                    });
                 }
             }
-            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}"];
+            // Use the data key if found, otherwise use call signature or function name
+            const mockNameToUse = dataKey ?? importedExport.calls?.[0] ?? `${importedExport.name}()`;
+            mockCode = constructMockCode(mockNameToUse, dependencySchemas, importedExport.entityType, undefined, { keepOriginalFunctionName: true });
+            // If constructMockCode didn't generate code, fall back to simple return
+            if (!mockCode && dataKey) {
+                mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${dataKey}"];
 
 function ${importedExport.name}() {
   return ${importedExport.name}ReturnValue;
 }`;
-                }
-            }
-            else {
-                // Original behavior for calls without variable names
-                mockCode = constructMockCode(importedExport.name, dependencySchemas, importedExport.entityType);
             }
         }
     }
@@ -764,6 +939,14 @@ function captureArgumentsForTesting(args) {
 }
 export default async function writeScenarioComponents({ project, file, entity, rootAnalysis, scenario, context, projectAnalyzer, framework, mocksDir, rootFile, namespaceMocks, writtenScenarioComponents = {}, fileStore, exportAsNamed, }) {
     var _a;
+    // Reset debug timing for this invocation
+    resetDebugTiming();
+    debugLog('START writeScenarioComponents', {
+        filePath: file.path,
+        entityName: entity.name,
+        scenarioName: scenario.name,
+        isRootFile: !rootFile || rootFile === file,
+    });
     // Capture arguments for testing if debug mode is enabled
     captureArgumentsForTesting({
         project,
@@ -907,7 +1090,20 @@ export default async function writeScenarioComponents({ project, file, entity, r
             return 1;
         return 0;
     });
+    debugLog('Starting main importedExports loop', {
+        count: sortedImportedExports.length,
+        fileContentLength: fileContent.length,
+    });
+    let importedExportIndex = 0;
     for (const importedExport of sortedImportedExports) {
+        importedExportIndex++;
+        if (importedExportIndex % 5 === 0 || importedExportIndex === 1) {
+            debugLog(`Processing importedExport ${importedExportIndex}/${sortedImportedExports.length}`, {
+                name: importedExport.name,
+                filePath: importedExport.filePath,
+                isMocked: importedExport.isMocked,
+            });
+        }
         // IMPORTANT: The import mapping keys may be either absolute or relative paths
         // depending on how they were created by the file analyzer. We try multiple formats.
         // Also need to normalize paths to handle /tmp vs /private/tmp on macOS
@@ -1034,7 +1230,11 @@ 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;
-                        const { scenarioComponentPaths: newScenarioComponentPaths, writtenScenarioComponents: updatedWrittenScenarioComponents, } = await writeScenarioComponents({
+                        debugLog(`Recursing into writeScenarioComponents for ${importedExportEntity.name}`, {
+                            entityName: importedExportEntity.name,
+                            filePath: fileNotMocked.path,
+                        });
+                        const { scenarioComponentPaths: newScenarioComponentPaths, writtenScenarioComponents: updatedWrittenScenarioComponents, } = await withTimeout(`recursive writeScenarioComponents for ${importedExportEntity.name}`, writeScenarioComponents({
                             project,
                             file: fileNotMocked,
                             entity: importedExportEntity,
@@ -1052,7 +1252,8 @@ export default async function writeScenarioComponents({ project, file, entity, r
                             exportAsNamed: needsNamedReExport
                                 ? importedExport.name
                                 : undefined,
-                        });
+                        }), 60000);
+                        debugLog(`Completed recursive writeScenarioComponents for ${importedExportEntity.name}`);
                         writtenScenarioComponents = updatedWrittenScenarioComponents;
                         scenarioComponentPaths.push(...newScenarioComponentPaths);
                     }
@@ -1286,9 +1487,7 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
                         : `import { ${entityImportName} } from '${path}';`;
                     // First, try to remove this entity from the already-rewritten grouped import
                     // This prevents duplicate/conflicting imports
-                    // IMPORTANT: Only remove from import statements, NOT from the entire file!
-                    // The global patterns used previously would also match type annotations like:
-                    //   "param: MyType," in function signatures, corrupting the syntax.
+                    // Use AST-based removal to properly handle type-only imports like `type EntityName`
                     const escapedEntityName = escapeRegExp(entityImportName);
                     // For default imports: remove "DefaultName, " from "import DefaultName, { ... }"
                     // This handles the case where a default export is being split out
@@ -1296,27 +1495,12 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
                         const defaultImportPattern = new RegExp(`(import\\s+)${escapedEntityName}\\s*,\\s*(\\{)`, 'gm');
                         fileContent = fileContent.replace(defaultImportPattern, '$1$2');
                     }
-                    // Match import statements that contain this entity and remove just the entity
-                    // Pattern: import { ... EntityName, ... } from '...'
-                    // We match the full import and use a replacer function to remove the entity name
-                    const importWithEntityPattern = new RegExp(`(import\\s*\\{)([^}]*\\b${escapedEntityName}\\b[^}]*)(\\}\\s*from\\s*['"][^'"]*['"];?)`, 'gm');
-                    fileContent = fileContent.replace(importWithEntityPattern, (match, prefix, namedImports, suffix) => {
-                        // Remove the entity name from the named imports
-                        let cleaned = namedImports
-                            .replace(new RegExp(`\\b${escapedEntityName}\\s*,\\s*`), '') // "EntityName, "
-                            .replace(new RegExp(`\\s*,\\s*${escapedEntityName}\\b`), '') // ", EntityName"
-                            .replace(new RegExp(`\\b${escapedEntityName}\\b`), ''); // "EntityName" (only one)
-                        // Clean up any double commas or leading/trailing commas
-                        cleaned = cleaned
-                            .replace(/,\s*,/g, ',')
-                            .replace(/^\s*,\s*/, '')
-                            .replace(/\s*,\s*$/, '');
-                        // If no imports left, remove the entire import statement
-                        if (cleaned.trim() === '') {
-                            return '';
-                        }
-                        return prefix + cleaned + suffix;
-                    });
+                    // Remove the named import using AST parsing
+                    // This properly handles:
+                    // - Regular imports: `import { EntityName } from '...'`
+                    // - Type-only imports: `import { type EntityName } from '...'`
+                    // - Mixed imports: `import { type EntityName, OtherName } from '...'`
+                    fileContent = removeNamedImportAst(fileContent, entityImportName);
                     // Add the new import at the beginning of fileContent
                     // Note: The header comment (// Scenario:) doesn't exist yet - it's prepended at writeFile time
                     // So prepending here puts the import right after the header in the final output
@@ -1330,17 +1514,27 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
             }
         }
     }
+    // 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 ?? [];
+    const nodeModuleUniversalMocks = universalMocks.filter((mock) => mock.nodeModule && mock.content);
+    // Create a set of import paths that have universal mocks for quick lookup
+    const universalMockPaths = new Set(nodeModuleUniversalMocks.map((mock) => mock.filePath));
     for (const nodeModuleImport of nodeModuleImports) {
         if (!nodeModuleImport.isMocked)
             continue;
+        // Skip generating local mock functions for imports that have universal mocks.
+        // Universal mocks provide the exports via rewritten import paths (handled below).
+        // Generating a local mock function would cause "name defined multiple times" errors.
+        if (universalMockPaths.has(nodeModuleImport.filePath)) {
+            continue;
+        }
         fileContent = addMockToContent(fileContent, nodeModuleImport, fileAnalyses, rootAnalysis, relativeMocksDir, scenario.name, importMapping[nodeModuleImport.filePath] ?? nodeModuleImport.filePath);
     }
     // Rewrite node_module imports that have universal mocks
     // Universal mocks create mock files at __codeyamMocks__/{safeFileName}.tsx
     // We need to rewrite imports like `import { logger } from "@formbricks/logger"`
     // to `import { logger } from "../__codeyamMocks__/_formbricks_logger.js"`
-    const universalMocks = project.metadata?.universalMocks ?? [];
-    const nodeModuleUniversalMocks = universalMocks.filter((mock) => mock.nodeModule && mock.content);
     for (const universalMock of nodeModuleUniversalMocks) {
         const originalPath = universalMock.filePath;
         // Create the mock file name using the same safeFileName function as writeUniversalMocks
@@ -1388,20 +1582,30 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
             scenario,
         });
     }
+    debugLog('Route path computed', { scenarioComponentPath });
     // Strip <html> and <body> tags from root layout files for Next.js
     // These tags cause hydration errors when the scenario layout is nested under the real root
+    debugLog('Starting stripHtmlBodyTags');
     fileContent = stripHtmlBodyTags(fileContent, file.path, framework);
+    debugLog('Completed stripHtmlBodyTags');
     // Strip "server-only" imports for Next.js
     // These cause errors when the scenario component is rendered client-side
+    debugLog('Starting stripServerOnlyImport');
     fileContent = stripServerOnlyImport(fileContent);
+    debugLog('Starting applyServerOnlyMocks');
     fileContent = applyServerOnlyMocks(fileContent);
+    debugLog('Completed server-only processing');
     // Rewrite asset imports (CSS, images, fonts, etc.) to correct relative paths
     // The original file path is relative to PROJECT_RELATIVE_PATH, the new path is scenarioComponentPath
+    debugLog('Starting rewriteAssetImports');
     fileContent = rewriteAssetImports(fileContent, `${PROJECT_RELATIVE_PATH}/${file.path}`, scenarioComponentPath);
+    debugLog('Completed rewriteAssetImports');
     // Rewrite relative TypeScript/JavaScript module imports to correct relative paths
     // This handles cases where the file is moved (e.g., from [environmentId]/ to _environmentId_/)
     // and relative imports like "./lib/organization" need to be rewritten
+    debugLog('Starting rewriteRelativeModuleImports');
     fileContent = rewriteRelativeModuleImports(fileContent, `${PROJECT_RELATIVE_PATH}/${file.path}`, scenarioComponentPath);
+    debugLog('Completed rewriteRelativeModuleImports');
     /**
      * 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.
@@ -1413,16 +1617,44 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
      * @param visitedPaths - Set of file paths currently being processed (for cycle detection)
      * @returns The modified content with imports rewritten to point to transitive copies
      */
-    async function processTransitiveImportsRecursively(content, sourceFilePath, targetFilePath, visitedPaths = new Set()) {
+    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 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);
+        debugLog(`processTransitiveImportsRecursively depth=${depth}`, {
+            sourceFilePath,
+            importCount: importPaths.length,
+            visitedCount: visitedPaths.size,
+        });
         let modifiedContent = content;
-        for (const importPath of importPaths) {
+        // Safety check: limit iterations to prevent infinite loops
+        const MAX_IMPORTS_PER_FILE = 100;
+        if (importPaths.length > MAX_IMPORTS_PER_FILE) {
+            console.warn(`[WriteScenario] WARNING: File ${sourceFilePath} has ${importPaths.length} imports (> ${MAX_IMPORTS_PER_FILE}), limiting processing`);
+        }
+        let importIndex = 0;
+        debugLog(`Starting import loop at depth=${depth}, ${importPaths.length} imports to process`);
+        const slicedImports = importPaths.slice(0, MAX_IMPORTS_PER_FILE);
+        for (const importPath of slicedImports) {
+            if (!importPath) {
+                continue;
+            }
+            importIndex++;
+            debugLog(`[LOOP] depth=${depth} import ${importIndex}/${Math.min(importPaths.length, MAX_IMPORTS_PER_FILE)}: ${importPath}`);
+            debugLog(`[LOOP] Calling resolveImportPath...`);
             const resolvedPath = resolveImportPath(importPath, sourceFilePath, project);
+            debugLog(`[LOOP] resolveImportPath returned: ${resolvedPath?.slice(0, 80) ?? 'null'}`);
             if (!resolvedPath)
                 continue;
+            debugLog(`[LOOP] Looking up importFile...`);
             let importFile = fileStore
                 ? fileStore.getByPath(resolvedPath)
                 : project.files?.find((f) => f.path === resolvedPath);
+            debugLog(`[LOOP] importFile lookup result: ${importFile ? 'found' : 'not found'}`);
             if (!importFile)
                 continue;
             // Build the transitive file path (needed for import rewriting even if we skip creating)
@@ -1450,8 +1682,17 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
                     // Strip server-only and mock server-only packages, then recursively process imports
                     let transitiveContent = stripServerOnlyImport(importFile.content);
                     transitiveContent = applyServerOnlyMocks(transitiveContent);
-                    transitiveContent = await processTransitiveImportsRecursively(transitiveContent, importFile.path, transitiveFilePath, visitedPaths);
+                    debugLog(`processTransitiveImportsRecursively depth=${depth} for ${importFile.path}`);
+                    debugLog(`Calling processTransitiveImportsRecursively depth=${depth + 1} for ${importFile.path}`);
+                    transitiveContent = await withTimeout(`processTransitiveImportsRecursively depth=${depth} for ${path.basename(importFile.path)}`, processTransitiveImportsRecursively(transitiveContent, importFile.path, transitiveFilePath, visitedPaths, depth + 1, startTime), 30000);
+                    debugLog(`withTimeout returned for depth=${depth}, transitiveContent length=${transitiveContent.length}`);
+                    debugLog(`Completed processTransitiveImportsRecursively depth=${depth} for ${importFile.path}`);
+                    debugLog(`Writing transitive file depth=${depth}`, {
+                        transitiveFilePath: path.basename(transitiveFilePath),
+                        contentLength: transitiveContent.length,
+                    });
                     await writeFile(transitiveFilePath, transitiveContent);
+                    debugLog(`Wrote transitive file depth=${depth}`);
                     scenarioComponentPaths.push(transitiveFilePath);
                     if (!writtenScenarioComponents[resolvedPath]) {
                         writtenScenarioComponents[resolvedPath] = [];
@@ -1461,22 +1702,63 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
             }
             // ALWAYS rewrite the import to point to the transitive copy
             // (even for circular imports or already-processed files)
+            debugLog(`Rewriting import path depth=${depth}`, {
+                importPath,
+                resolvedPath,
+            });
             const relativePath = getRelativePath(targetFilePath, transitiveFilePath);
             const relativePathWithoutExt = relativePath.replace(/\.(ts|tsx|js|jsx)$/, '');
             const safeRelativePath = safeFolder(relativePathWithoutExt);
             const escapedImportPath = importPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const importRegex = new RegExp(`(from\\s*["'])${escapedImportPath}(["'])`, 'g');
-            modifiedContent = modifiedContent.replace(importRegex, `$1${safeRelativePath}$2`);
+            debugLog(`Applying regex depth=${depth}`, {
+                escapedImportPath,
+                contentLength: modifiedContent.length,
+            });
+            // Quick check if the import path even exists in content
+            const simpleCheck = modifiedContent.includes(importPath);
+            debugLog(`Simple check: importPath "${importPath}" exists: ${simpleCheck}`);
+            if (!simpleCheck) {
+                debugLog(`Skipping regex - import path not found in content`);
+            }
+            else {
+                const regexPattern = `(from\\s*["'])${escapedImportPath}(["'])`;
+                debugLog(`Regex pattern: ${regexPattern.slice(0, 100)}`);
+                const importRegex = new RegExp(regexPattern, 'g');
+                debugLog(`About to call replace...`);
+                // Timing for regex replace to detect slow operations
+                const replaceStart = Date.now();
+                modifiedContent = modifiedContent.replace(importRegex, `$1${safeRelativePath}$2`);
+                const replaceTime = Date.now() - replaceStart;
+                if (replaceTime > 100) {
+                    console.warn(`[WriteScenario] SLOW regex replace: ${replaceTime}ms for pattern ${regexPattern.slice(0, 50)} on ${modifiedContent.length} bytes`);
+                }
+                debugLog(`Regex applied depth=${depth} in ${replaceTime}ms`);
+            }
+            debugLog(`[LOOP END] depth=${depth} import ${importIndex} completed`);
         }
+        debugLog(`[LOOP DONE] Exiting import loop at depth=${depth}`);
+        debugLog(`Returning from processTransitiveImportsRecursively depth=${depth}`);
         return modifiedContent;
     }
     // 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"
+    debugLog('Extracting remaining import paths');
     const remainingImportPaths = extractInternalImportPaths(fileContent);
+    debugLog('Found remaining import paths', {
+        count: remainingImportPaths.length,
+    });
     // Get all file paths that are in importedExports - these are handled by main processing
     const importedExportFilePaths = new Set(allImportedExports.map((ie) => ie.resolvedFilePath || ie.filePath));
+    debugLog('Starting remaining imports loop', {
+        remainingCount: remainingImportPaths.length,
+        importedExportCount: importedExportFilePaths.size,
+    });
+    let remainingImportIndex = 0;
+    debugLog(`[REMAINING] Starting remaining imports loop, ${remainingImportPaths.length} imports`);
     for (const importPath of remainingImportPaths) {
+        remainingImportIndex++;
+        debugLog(`[REMAINING LOOP] import ${remainingImportIndex}/${remainingImportPaths.length}: ${importPath}`);
         // Resolve the import path to a project file path
         const resolvedFilePath = resolveImportPath(importPath, file.path, project);
         if (!resolvedFilePath) {
@@ -1537,7 +1819,11 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
             // Recursively process this transitive file's imports
             // This handles the nested case: service.ts → brevo.ts → constants.ts
             const nestedImportPaths = extractInternalImportPaths(transformedContent);
+            debugLog(`[NESTED] Processing ${nestedImportPaths.length} nested imports for ${targetFile.path}`);
+            let nestedIndex = 0;
             for (const nestedImportPath of nestedImportPaths) {
+                nestedIndex++;
+                debugLog(`[NESTED LOOP] import ${nestedIndex}/${nestedImportPaths.length}: ${nestedImportPath}`);
                 const nestedResolvedPath = resolveImportPath(nestedImportPath, targetFile.path, project);
                 if (!nestedResolvedPath)
                     continue;
@@ -1568,7 +1854,9 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
                     // This handles chains of any depth: A -> B -> C -> D
                     let nestedContent = stripServerOnlyImport(nestedFile.content);
                     nestedContent = applyServerOnlyMocks(nestedContent);
-                    nestedContent = await processTransitiveImportsRecursively(nestedContent, nestedFile.path, nestedTransformedPath);
+                    debugLog(`processTransitiveImportsRecursively (nested) for ${nestedFile.path}`);
+                    nestedContent = await withTimeout(`processTransitiveImportsRecursively (nested) for ${path.basename(nestedFile.path)}`, processTransitiveImportsRecursively(nestedContent, nestedFile.path, nestedTransformedPath), 30000);
+                    debugLog(`Completed processTransitiveImportsRecursively (nested) for ${nestedFile.path}`);
                     await writeFile(nestedTransformedPath, nestedContent);
                     scenarioComponentPaths.push(nestedTransformedPath);
                     // Mark as written
@@ -1639,7 +1927,12 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     else {
         finalContent = `${scenarioComponentComment}\n\n${fileContent}`;
     }
+    debugLog('About to write final scenario file', {
+        scenarioComponentPath,
+        contentLength: finalContent.length,
+    });
     await writeFile(scenarioComponentPath, finalContent);
+    debugLog('Successfully wrote scenario file');
     scenarioComponentPaths.push(scenarioComponentPath);
     return { scenarioComponentPaths, writtenScenarioComponents };
 }