@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.bd4126b

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

@@ -4,9 +4,89 @@ import { isFrameworkRoute, getFrameworkRoutePath, safeFileName, PROJECT_RELATIVE
 import { getRelativePath, safeFolder } from "../../../../../packages/generate/index.js";
 import constructMockCode from "./constructMockCode.js";
 import { splitOutsideParenthesesAndArrays } from "../../../../../packages/ai/index.js";
-import { loadEntities } from "../../../../../packages/supabase/index.js";
 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.
+ *
+ * @param content - The file content to analyze
+ * @returns The position after the last import statement, or 0 if no imports found
+ */
+function findEndOfImports(content) {
+    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.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) {
+            if (ts.isImportDeclaration(statement)) {
+                // Get the end position including any trailing semicolon/newline
+                lastImportEnd = statement.end;
+            }
+            else if (ts.isExportDeclaration(statement) &&
+                statement.moduleSpecifier) {
+                // Handle "export { x } from 'module'" style re-exports
+                lastImportEnd = statement.end;
+            }
+        }
+        return lastImportEnd;
+    }
+    catch (error) {
+        // If parsing fails, fall back to 0 (will append at end)
+        console.warn('CodeYam: Failed to parse file for import detection:', error);
+        return 0;
+    }
+}
 /**
  * Escape special regex characters in a string so it can be used as a literal pattern.
  * This prevents characters like . * + ? ^ $ { } ( ) | [ ] \ from being interpreted as regex metacharacters.
@@ -14,6 +94,125 @@ import * as path from 'path';
 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:
+ *   packages/X/dist/X/src/Y.d.ts
+ * when the source is at:
+ *   packages/X/src/Y.ts
+ * This function normalizes such paths to the src location.
+ */
+function mapNestedDistToSrc(filePath) {
+    // Pattern: packages/X/dist/X/src/Y -> packages/X/src/Y
+    const nestedDistMatch = filePath.match(/^(packages\/[^/]+)\/dist\/[^/]+\/src\/(.+)$/);
+    if (nestedDistMatch) {
+        const [, packagePath, relativePath] = nestedDistMatch;
+        return `${packagePath}/src/${relativePath}`
+            .replace(/\.d\.ts$/, '.ts')
+            .replace(/\.js$/, '.ts');
+    }
+    return filePath;
+}
 function hasMockStructure(importedExport, fileAnalyses) {
     if (!fileAnalyses?.some((a) => a.entity.metadata?.isolatedDataStructure?.dependencySchemas)) {
         return false;
@@ -73,7 +272,6 @@ function convertDtsToStubs(content, entityName) {
     result = result.replace(/export\s*\{\s*\}\s*;?\s*$/g, '');
     // Keep export type and export interface statements as-is (they're valid in .ts)
     // No transformation needed for these
-    console.log(`CodeYam: Converted .d.ts content for entity "${entityName}". Result length: ${result.length}`);
     return result;
 }
 /**
@@ -144,9 +342,10 @@ function rewriteRelativeModuleImports(fileContent, originalFilePath, newFilePath
         // Skip imports that already point to generated CodeYam files:
         // 1. Scenario component files with SHA hashes (64 hex chars) and scenario name suffixes
         //    e.g., "abc123def_EnvironmentLayout_Empty_Survey_No_Responses"
+        //    e.g., "abc123def_EnvironmentLayout_Survey_not_found_404" (scenario names can contain digits)
         // 2. Mock data files in __codeyamMocks__ directory
         //    e.g., "../__codeyamMocks__/MockData_Empty_Survey_No_Responses"
-        const scenarioFilePattern = /[a-f0-9]{64}_\w+_[A-Z][a-zA-Z_]+$/;
+        const scenarioFilePattern = /[a-f0-9]{64}_\w+_[A-Z]\w*$/;
         const mockDataPattern = /__codeyamMocks__\//;
         if (scenarioFilePattern.test(importPath) ||
             mockDataPattern.test(importPath)) {
@@ -210,7 +409,6 @@ function stripHtmlBodyTags(fileContent, filePath, framework) {
     if (!/<html[^>]*>/.test(fileContent) || !/<body[^>]*>/.test(fileContent)) {
         return fileContent;
     }
-    console.log(`CodeYam: Stripping <html> and <body> tags from root layout: ${filePath}`);
     // Extract the body className/attributes if any, to preserve styling
     const bodyMatch = fileContent.match(/<body([^>]*)>/);
     const bodyAttributes = bodyMatch?.[1]?.trim() || '';
@@ -248,6 +446,145 @@ function stripHtmlBodyTags(fileContent, filePath, framework) {
     }
     return result;
 }
+/**
+ * Strip `import "server-only"` or `import 'server-only'` directives from file content.
+ *
+ * Next.js "server-only" package is used to mark modules that should only run on the server.
+ * When we generate scenario components for client-side rendering in the browser, importing
+ * a file with this directive causes an error:
+ *
+ *   "You're importing a component that needs 'server-only'. That only works in a Server Component"
+ *
+ * Since our scenario components are rendered client-side for capture purposes, we need to
+ * strip this import to allow the file to be imported.
+ */
+function stripServerOnlyImport(fileContent) {
+    // Match import "server-only" or import 'server-only' with optional semicolon and newline
+    // Handles both double and single quotes, with or without trailing semicolon
+    return fileContent.replace(/import\s+["']server-only["'];?\s*\n?/g, '');
+}
+/**
+ * Extract all internal import paths from file content.
+ * Internal imports are those that start with '.', '@/', '~/', or are relative paths.
+ * 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 = [];
+    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;
+}
+/**
+ * Resolve an import path to a file path relative to the project.
+ * Handles path aliases like @/, ~/, and relative paths.
+ */
+function resolveImportPath(importPath, currentFilePath, project) {
+    let resolvedPath;
+    let appPrefix = '';
+    if (importPath.startsWith('./') || importPath.startsWith('../')) {
+        // Relative import - resolve relative to current file
+        const currentDir = currentFilePath.split('/').slice(0, -1).join('/');
+        const parts = [...currentDir.split('/'), ...importPath.split('/')];
+        const resolved = [];
+        for (const part of parts) {
+            if (part === '..') {
+                resolved.pop();
+            }
+            else if (part !== '.' && part !== '') {
+                resolved.push(part);
+            }
+        }
+        resolvedPath = resolved.join('/');
+    }
+    else if (importPath.startsWith('@/') || importPath.startsWith('~/')) {
+        // Path alias - strip the prefix
+        resolvedPath = importPath.slice(2);
+        // Infer app prefix from current file path
+        // e.g., if currentFilePath is "apps/web/lib/user/service.ts"
+        // and import is "@/modules/auth/lib/brevo", the actual file is at
+        // "apps/web/modules/auth/lib/brevo.ts"
+        // We detect this by checking if current file starts with "apps/XXX/"
+        const appMatch = currentFilePath.match(/^(apps\/[^/]+\/)/);
+        if (appMatch) {
+            appPrefix = appMatch[1];
+        }
+    }
+    else if (importPath.startsWith('#')) {
+        // Package imports - not supported yet
+        return null;
+    }
+    else {
+        // Unknown format
+        return null;
+    }
+    // Try to find the file with various extensions
+    const extensions = ['', '.ts', '.tsx', '.js', '.jsx'];
+    // First try with app prefix (for monorepo structures like apps/web/)
+    if (appPrefix) {
+        for (const ext of extensions) {
+            const fullPath = appPrefix + resolvedPath + ext;
+            const file = project.files?.find((f) => f.path === fullPath);
+            if (file) {
+                return file.path;
+            }
+        }
+        // Try index files with prefix
+        for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+            const indexPath = `${appPrefix}${resolvedPath}/index${ext}`;
+            const file = project.files?.find((f) => f.path === indexPath);
+            if (file) {
+                return file.path;
+            }
+        }
+    }
+    // Then try without prefix (for simpler project structures)
+    for (const ext of extensions) {
+        const fullPath = resolvedPath + ext;
+        const file = project.files?.find((f) => f.path === fullPath);
+        if (file) {
+            return file.path;
+        }
+    }
+    // Try index files
+    for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+        const indexPath = `${resolvedPath}/index${ext}`;
+        const file = project.files?.find((f) => f.path === indexPath);
+        if (file) {
+            return file.path;
+        }
+    }
+    return null;
+}
+// Version for tracking deployments - increment when making changes
+const WRITE_SCENARIO_COMPONENTS_VERSION = '2.5.17-configurable-server-mocks';
 function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysis, relativeMocksDir, scenarioName, importPath) {
     // First try to find dependency schemas in fileAnalyses (for same-file dependencies)
     let dependencySchemas = fileAnalyses.find((a) => !!a.metadata?.mergedDataStructure?.dependencySchemas?.[importedExport.filePath]?.[importedExport.name])?.metadata?.mergedDataStructure?.dependencySchemas;
@@ -257,21 +594,262 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
         dependencySchemas =
             rootAnalysis.metadata?.mergedDataStructure?.dependencySchemas;
     }
-    const mockCode = constructMockCode(importedExport.name, dependencySchemas, importedExport.entityType);
-    if (!mockCode) {
-        console.log('CodeYam Error: Mock code not found', JSON.stringify({
-            importedExportFilePath: importedExport.filePath,
-            importedExportEntityName: importedExport.name,
-            analysisIds: fileAnalyses.map((a) => ({
-                id: a.id,
-                filePath: a.filePath,
-                entityName: a.entityName,
-            })),
-            analysisFilePath: fileAnalyses?.[0]?.filePath,
-            analysisEntityNames: fileAnalyses.map((a) => a.entityName),
-            dependencySchemas: fileAnalyses.find((a) => !!a.entity.metadata?.isolatedDataStructure?.dependencySchemas?.[importedExport.filePath]?.[importedExport.name])?.entity.metadata?.isolatedDataStructure?.dependencySchemas,
-            allDependencySchemas: fileAnalyses.map((a) => a.entity.metadata?.isolatedDataStructure?.dependencySchemas),
-        }, null, 2));
+    // 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 = baseHookCalls &&
+        baseHookCalls.length > 1 &&
+        importedExport.callVariableNames &&
+        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
+        // 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 = {};
+        // 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;
+            // Build indexed variable name for function naming
+            const indexedVariableName = occurrence > 0 ? `${variableName}[${occurrence}]` : variableName;
+            // 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()
+                // Escape special regex characters in the call signature
+                const escapedCallSignature = callSignature.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                // 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}()`);
+            }
+        }
+    }
+    else {
+        // Check if there's a single variable name that receives this function's return value
+        // Note: callVariableNames tracks the ACTUAL variable assignments (e.g., "const loadError = useLoaderData()")
+        // while calls can contain many entries including method chain accesses (e.g., "useLoaderData().config...")
+        // We only care about how many distinct variables receive the return value.
+        const singleCallVariableName = importedExport.callVariableNames &&
+            importedExport.callVariableNames.length === 1
+            ? importedExport.callVariableNames[0]
+            : undefined;
+        if (singleCallVariableName) {
+            // 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 = `// 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 {
+            // 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;
+                }
+                // 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;
+                }
+            }
+            // 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;
+}`;
+            }
+        }
+    }
+    // Combine all mock codes
+    const allMockCodes = variableMockCodes.length > 0 ? variableMockCodes.join('\n\n') : mockCode;
+    if (!allMockCodes) {
         return fileContent;
     }
     if (importPath) {
@@ -284,13 +862,44 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
         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, '');
@@ -306,7 +915,17 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
         // 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`);
         }
@@ -316,13 +935,29 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
         // Clean up empty imports that might result from removing the only import
         fileContent = fileContent.replace(/import\s*\{\s*\}\s*from\s+['"][^'"]*['"];?\s*\n?/g, '');
     }
+    // Find the last import position using TypeScript AST (more reliable than regex).
+    // This ensures we insert both the scenarios import AND the mock after the original imports,
+    // not at the end of the file.
+    const lastImportEnd = findEndOfImports(fileContent);
+    // Build the content to insert: scenarios import (if needed) + mock
+    let insertContent = '';
     if (fileContent.indexOf('import { scenarios } from') === -1) {
         // Use scenario-specific MockData file to allow multiple scenarios to coexist
         const mockDataPath = `${relativeMocksDir}/MockData_${safeFileName(scenarioName)}`;
-        const importStatement = `import { scenarios } from "${mockDataPath}";`;
-        fileContent = `${fileContent}\n\n\n${importStatement}`;
+        insertContent += `\n\nimport { scenarios } from "${mockDataPath}";`;
+    }
+    insertContent += `\n\n// Mock constructed using mocksDataStructure from analyses: ${fileAnalyses.map((a) => a.id).join(', ')}\n${allMockCodes}`;
+    if (lastImportEnd > 0) {
+        // Insert after the last original import
+        fileContent =
+            fileContent.slice(0, lastImportEnd) +
+                insertContent +
+                fileContent.slice(lastImportEnd);
+    }
+    else {
+        // Fallback: append at end if no imports found
+        fileContent += insertContent;
     }
-    fileContent += `\n\n// Mock constructed using mocksDataStructure from analyses: ${fileAnalyses.map((a) => a.id).join(', ')}\n${mockCode}`;
     return fileContent;
 }
 // Debug utility to capture complex arguments for testing
@@ -467,6 +1102,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,
@@ -539,8 +1182,33 @@ export default async function writeScenarioComponents({ project, file, entity, r
     // .d.ts files only have type declarations (e.g., "export declare const logger")
     // which don't provide runtime exports. We need to generate actual stub implementations.
     if (file.path.endsWith('.d.ts')) {
-        console.log(`CodeYam: Converting .d.ts file to stub implementations: ${file.path}`);
         fileContent = convertDtsToStubs(fileContent, entity.name);
+        // After basic .d.ts conversion, enhance the entity's stub with proper mock code
+        // if we have dependency schema data showing its methods/properties.
+        // This prevents "X.method is not a function" errors at runtime.
+        //
+        // NOTE: constructMockCode iterates through ALL file paths in dependencySchemas
+        // to find the entity, so we don't need to check for an exact file path match.
+        // The entity might be stored under a different path (e.g., import alias like
+        // @formbricks/logger vs the actual file path packages/logger/dist/index.d.ts).
+        const dependencySchemas = rootAnalysis.metadata?.mergedDataStructure?.dependencySchemas;
+        if (dependencySchemas) {
+            const mockCode = constructMockCode(entity.name, dependencySchemas, entity.entityType);
+            if (mockCode) {
+                // Replace the simple `export const entityName = {} as any;` with the full mock code
+                // The mockCode generates `const entityName = { ... }` so we need to add `export`
+                const stubPattern = new RegExp(`export\\s+(const|let|var)\\s+${escapeRegExp(entity.name)}\\s*=\\s*\\{\\s*\\}\\s+as\\s+any;?`);
+                if (fileContent.match(stubPattern)) {
+                    // Add export keyword to the mock code since constructMockCode generates `const name = ...`
+                    const exportMockCode = mockCode.replace(/^(const|let|var)\s+/, 'export $1 ');
+                    fileContent = fileContent.replace(stubPattern, exportMockCode);
+                    // Add scenarios import at the top for the mock to work
+                    const relativeMocksDir = getRelativePath(file.path, mocksDir);
+                    const mockDataPath = `${relativeMocksDir}/MockData_${safeFileName(scenario.name)}`;
+                    fileContent = `import { scenarios } from "${mockDataPath}";\n\n${fileContent}`;
+                }
+            }
+        }
     }
     // Extract "use client" or "use server" directive FIRST, before any modifications
     // This ensures the directive isn't buried by prepended imports
@@ -585,7 +1253,23 @@ 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;
+    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,
+                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
@@ -598,44 +1282,42 @@ export default async function writeScenarioComponents({ project, file, entity, r
         const resolvedFilePathForLookup = importedExport.resolvedFilePath
             ? normalizePath(`${projectAnalyzer.dirPath}/${importedExport.resolvedFilePath}`)
             : undefined;
-        let importedExportEntity = context.getEntity(importedExport.resolvedFilePath ?? importedExport.filePath, importedExport.resolvedName ?? importedExport.name) ?? context.getEntity(importedExport.resolvedFilePath, 'default');
-        if (!importedExportEntity) {
-            console.log('CodeYam Error: Entity not found', JSON.stringify({
-                filePath: file.path,
-                entityName: entity.name,
-                analysisIds: fileAnalyses.map((a) => a.id),
-                analysisFilePath: fileAnalyses[0]?.filePath,
-                analysisEntityName: fileAnalyses.map((a) => a.entityName),
-                importedExport,
-                contextEntitiesForFilePath: context.getEntityNamesForFile(importedExport.filePath),
-                contextEntitiesForResolvedFilePath: context.getEntityNamesForFile(importedExport.resolvedFilePath),
-            }, null, 2));
-            // Why is this necessary? The entity should be in the context.
-            const candidateEntities = await loadEntities({
-                projectId: project.id,
-                filePaths: [importedExport.resolvedFilePath ?? importedExport.filePath],
-                names: [importedExport.resolvedName ?? importedExport.name],
-            });
-            importedExportEntity = candidateEntities.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
-            if (!importedExportEntity) {
-                throw new Error('importedExportEntity not found in writeScenarioComponents');
+        const importedExportEntity = context.getEntity(importedExport.resolvedFilePath ?? importedExport.filePath, importedExport.resolvedName ?? importedExport.name) ?? context.getEntity(importedExport.resolvedFilePath, 'default');
+        // Check if we actually need the entity for this import
+        const importedExportFilePath = importedExport.resolvedFilePath ?? importedExport.filePath;
+        const isSameFile = importedExportFilePath === file.path;
+        // We only need the entity for non-mocked, different-file imports:
+        // - Same-file imports: skip to the isCurrentFile check later (line ~1203)
+        // - Mocked imports: use importedExport.entityType, not importedExportEntity
+        // - Non-mocked different-file: need entity for type check, recursive call, and path rewriting
+        if (!importedExportEntity && !isSameFile && !importedExport.isMocked) {
+            // Check if the file exists in project.files - if not, skip this import.
+            // This happens when a file is excluded from project.files (e.g., Prisma-generated client.ts)
+            // but entities still have importedExports referencing it.
+            const fileExistsInProject = fileStore
+                ? fileStore.getByPath(importedExportFilePath)
+                : project.files.find((f) => f.path === importedExportFilePath);
+            if (!fileExistsInProject) {
+                // File not in project.files - likely auto-generated or excluded. Skip it.
+                continue;
             }
+            // All entities should be pre-loaded by loadReadyToBeCaptured's gatherAllReferencedEntities.
+            // If we're here, that function has a bug or an edge case was missed.
+            throw new Error(`Entity not found in context: ${importedExport.resolvedFilePath ?? importedExport.filePath}:${importedExport.resolvedName ?? importedExport.name}\n` +
+                `Looking up for: ${file.path}:${entity.name}\n` +
+                `Context entities for file: ${JSON.stringify(context.getEntityNamesForFile(importedExport.filePath))}\n` +
+                `Context entities for resolved: ${JSON.stringify(context.getEntityNamesForFile(importedExport.resolvedFilePath))}`);
+        }
+        if (importedExportEntity) {
+            importedExportEntity.localFilePath = importedExport.filePath;
         }
-        importedExportEntity.localFilePath = importedExport.filePath;
         if (!importedExport.isMocked) {
             // Use resolvedFilePath (actual entity location) for scenario component writing.
             // This is critical for re-exports: when importing from index.tsx which re-exports
             // from a nested file, we need to write scenario components for the actual file
             // where the entity code lives, not the re-export file.
-            const importedExportFilePath = importedExport.resolvedFilePath ?? importedExport.filePath;
-            if (importedExportFilePath !== file.path) {
+            if (!isSameFile) {
                 if (!writtenScenarioComponents[importedExportFilePath]?.includes(importedExport.name)) {
-                    // Skip recursion for type/data entities - they don't need scenario components
-                    // Only recurse for visual and library entities that need mocking
-                    if (importedExportEntity.entityType === 'type' ||
-                        importedExportEntity.entityType === 'data') {
-                        continue;
-                    }
                     // Use fileStore for O(1) lookup when available
                     let fileNotMocked = fileStore
                         ? fileStore.getByPath(importedExportFilePath)
@@ -661,30 +1343,89 @@ export default async function writeScenarioComponents({ project, file, entity, r
                         !fileStore.isContentLoaded(fileNotMocked.path)) {
                         fileNotMocked = await fileStore.ensureContent(fileNotMocked.path);
                     }
-                    // When a default export is imported as named (via index re-export), we need
-                    // to add a named re-export to the scenario component so the import works.
-                    // 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({
-                        project,
-                        file: fileNotMocked,
-                        entity: importedExportEntity,
-                        rootAnalysis,
-                        scenario,
-                        context,
-                        projectAnalyzer,
-                        framework,
-                        mocksDir,
-                        rootFile,
-                        namespaceMocks,
-                        writtenScenarioComponents,
-                        fileStore,
-                        // Pass the import name so we can add `export { default as Name };`
-                        exportAsNamed: needsNamedReExport ? importedExport.name : undefined,
-                    });
-                    writtenScenarioComponents = updatedWrittenScenarioComponents;
-                    scenarioComponentPaths.push(...newScenarioComponentPaths);
+                    // For type/data entities, create a transformed copy WITHOUT recursion.
+                    // Data entities don't need mocking - they're just constants/types that need
+                    // to be available. But we still need to:
+                    // 1. Strip server-only imports (Next.js directive that breaks client components)
+                    // 2. Write the transformed file so imports can be rewritten to point to it
+                    if (importedExportEntity.entityType === 'type' ||
+                        importedExportEntity.entityType === 'data') {
+                        // For data entities, we write ONE transformed copy per source file, not per entity.
+                        // Check if we've already written ANY entity from this file - if so, skip writing.
+                        // Use a special marker '__data_file_written__' to track file-level writes.
+                        // Also track which SHA was used via '__data_file_sha__:xxx' so subsequent
+                        // entities from the same file can reuse it for import rewriting.
+                        const dataFileWritten = writtenScenarioComponents[importedExportFilePath]?.includes('__data_file_written__');
+                        if (!dataFileWritten) {
+                            // Construct the scenario file path for the data file
+                            // Use a file-level identifier (first entity's sha) for consistency
+                            const dataFileBasePath = safeFolder(fileNotMocked.path.split('/').slice(0, -1).join('/'));
+                            const dataFileExtension = fileNotMocked.name.split('.').pop();
+                            const dataFileIsIndex = isIndexPath(fileNotMocked.path);
+                            // Use 'data' prefix to distinguish from entity-specific files
+                            const dataScenarioPath = `${PROJECT_RELATIVE_PATH}/${dataFileBasePath}/${importedExportEntity.sha}_${dataFileIsIndex ? 'index_' : ''}data_${safeFileName(scenario.name)}.${dataFileExtension}`;
+                            // Get the file content and apply transformations
+                            let dataFileContent = fileNotMocked.content ?? '';
+                            // Strip server-only imports - these break when imported by client components
+                            dataFileContent = stripServerOnlyImport(dataFileContent);
+                            dataFileContent = applyServerOnlyMocks(dataFileContent);
+                            // Write the transformed data entity file
+                            await writeFile(dataScenarioPath, dataFileContent);
+                            scenarioComponentPaths.push(dataScenarioPath);
+                            // Mark file as written so we don't duplicate for other entities from same file
+                            if (!writtenScenarioComponents[importedExportFilePath]) {
+                                writtenScenarioComponents[importedExportFilePath] = [];
+                            }
+                            writtenScenarioComponents[importedExportFilePath].push('__data_file_written__');
+                            // Also store the SHA used for this data file so subsequent entities can use it
+                            writtenScenarioComponents[importedExportFilePath].push(`__data_file_sha__:${importedExportEntity.sha}`);
+                        }
+                        // Mark this specific entity as written (for the entity-level check)
+                        if (!writtenScenarioComponents[importedExportFilePath]) {
+                            writtenScenarioComponents[importedExportFilePath] = [];
+                        }
+                        writtenScenarioComponents[importedExportFilePath].push(importedExport.name);
+                        // Don't recurse - data entities don't need their dependencies processed
+                        // The import rewriting will happen later in this same loop iteration
+                        // (at lines ~1590-1702) to point imports to this transformed file
+                    }
+                    else {
+                        // For visual/library entities, recurse to process their dependencies
+                        // When a default export is imported as named (via index re-export), we need
+                        // to add a named re-export to the scenario component so the import works.
+                        // 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,
+                        });
+                        const { scenarioComponentPaths: newScenarioComponentPaths, writtenScenarioComponents: updatedWrittenScenarioComponents, } = await withTimeout(`recursive writeScenarioComponents for ${importedExportEntity.name}`, writeScenarioComponents({
+                            project,
+                            file: fileNotMocked,
+                            entity: importedExportEntity,
+                            rootAnalysis,
+                            scenario,
+                            context,
+                            projectAnalyzer,
+                            framework,
+                            mocksDir,
+                            rootFile,
+                            namespaceMocks,
+                            writtenScenarioComponents,
+                            fileStore,
+                            // Pass the import name so we can add `export { default as Name };`
+                            exportAsNamed: needsNamedReExport
+                                ? importedExport.name
+                                : undefined,
+                        }), 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);
+                    }
                 }
             }
         }
@@ -699,16 +1440,22 @@ export default async function writeScenarioComponents({ project, file, entity, r
             // Data and type entities should be preserved - they're not callable and may have methods
             // that stubbing would break (e.g., Zod schemas with .superRefine())
             const isDataEntity = entityType === 'data' || entityType === 'type';
-            // Heuristic: Zod schemas are often misclassified as 'library' but should be preserved
-            // Detect by: name starts with Z + uppercase letter, AND has Zod method calls
-            const looksLikeZodSchema = entityType === 'library' &&
-                /^Z[A-Z]/.test(importedExport.name) &&
-                importedExport.calls?.some((call) => /\.(superRefine|refine|transform|default|optional|nullable|array|object|string|number|boolean|parse|safeParse)\s*\(/.test(call));
-            if (looksLikeZodSchema) {
-                console.log(`CodeYam: Detected Zod schema "${importedExport.name}" (misclassified as library) - will preserve`);
-            }
-            // Callable entities can be safely stubbed (but not Zod schemas)
-            const isCallable = !isDataEntity && !looksLikeZodSchema && entityType !== undefined;
+            // If calls data shows the entity is only accessed via properties/methods
+            // (e.g., formValidator.validate(), schema.superRefine()) and never directly
+            // invoked (e.g., getInitialProps()), it's used as an object and should be
+            // preserved rather than replaced with a Proxy stub.
+            const onlyPropertyAccessed = importedExport.calls?.length > 0 &&
+                !importedExport.calls.some((call) => {
+                    const afterName = call.slice(importedExport.name.length);
+                    return afterName.startsWith('(') || afterName.startsWith('<');
+                });
+            // Callable entities can be safely stubbed. Entities that are only
+            // property-accessed should be preserved (their methods need to work).
+            // 'other' entities are unknown types — safer to preserve than stub.
+            const isCallable = !isDataEntity &&
+                !onlyPropertyAccessed &&
+                entityType !== undefined &&
+                entityType !== 'other';
             // Determine what action to take
             const shouldStripAndReplace = hasMock;
             const shouldStripAndStub = !hasMock && importedExport.isMocked && isCallable;
@@ -722,16 +1469,15 @@ export default async function writeScenarioComponents({ project, file, entity, r
             if (shouldPreserve) {
                 // For data entities (like Zod schemas), don't strip or stub - preserve the original
                 // This ensures schema methods like .superRefine() continue to work
-                console.log(`CodeYam: Preserving ${importedExport.name} (entityType: ${entityType}) - not stripping data entities`);
                 // Don't modify fileContent - keep the original code
             }
             else if (shouldStripAndReplace || shouldStripAndStub) {
                 // Strip the original code
                 const entityCode = fileAnalyzer.getEntityCode(importedExport.name);
-                if (entityCode) {
-                    fileContent = fileContent.replace(entityCode, '');
-                }
                 if (shouldStripAndReplace) {
+                    if (entityCode) {
+                        fileContent = fileContent.replace(entityCode, '');
+                    }
                     // Add mock from mock structure
                     fileContent = addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysis, relativeMocksDir, scenario.name);
                 }
@@ -740,16 +1486,44 @@ export default async function writeScenarioComponents({ project, file, entity, r
                     // This prevents ReferenceError at runtime when the stripped
                     // function is called (e.g., local helper functions like getInitialProps).
                     const functionName = importedExport.name;
-                    console.log(`CodeYam: Generating stub mock for ${functionName} (entityType: ${entityType}) in ${file.path}`);
                     // Add scenarios import if not present
                     if (fileContent.indexOf('import { scenarios } from') === -1) {
                         const mockDataPath = `${relativeMocksDir}/MockData_${safeFileName(scenario.name)}`;
                         const importStatement = `import { scenarios } from "${mockDataPath}";`;
                         fileContent = `${fileContent}\n\n\n${importStatement}`;
                     }
-                    // Generate a simple stub that returns the scenario data for this function
-                    const stubMock = `\n\n// Stub mock for local function without mock structure\nfunction ${functionName}(...args) {\n  return scenarios().data()?.["${functionName}()"];\n}`;
-                    fileContent += stubMock;
+                    // Check if the original entity was exported - if so, the stub should be exported too
+                    // This ensures other files that import this entity can still access it
+                    const wasExported = entityCode?.trimStart().startsWith('export');
+                    const exportKeyword = wasExported ? 'export ' : '';
+                    // Generate a chainable stub mock using a Proxy
+                    // This handles cases where the entity is used with method chains like:
+                    //   actionClient.use(...).use(...)
+                    // The Proxy returns itself for any property access, making it infinitely chainable.
+                    // When called as a function, it returns the scenario data.
+                    const stubMock = `// Stub mock for local function without mock structure
+// Uses a Proxy to support method chaining (e.g., ${functionName}.use(...))
+const _${functionName}Handler = {
+  get: function(target, prop) {
+    if (prop === 'then') return undefined; // Prevent Promise-like behavior
+    return (...args) => new Proxy(() => scenarios().data()?.["${functionName}()"], _${functionName}Handler);
+  },
+  apply: function(target, thisArg, args) {
+    return scenarios().data()?.["${functionName}()"];
+  }
+};
+${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${functionName}()"], _${functionName}Handler);`;
+                    // Replace the original entity code with the stub mock IN PLACE
+                    // This is critical to maintain the original ordering of declarations.
+                    // If we append the stub at the end, code that uses this entity before
+                    // the stub definition will fail with "Cannot access X before initialization".
+                    if (entityCode) {
+                        fileContent = fileContent.replace(entityCode, stubMock);
+                    }
+                    else {
+                        // Fallback: append at end if we can't find the original code
+                        fileContent += `\n\n${stubMock}`;
+                    }
                 }
             }
         }
@@ -759,8 +1533,9 @@ export default async function writeScenarioComponents({ project, file, entity, r
         // because that's how imports are written in source code
         const mockFilePathRelative = importedExport.filePath;
         // For scenario component paths, prefer resolvedFilePath (where entity actually lives)
-        // because that's where scenario component files are written
-        const scenarioFilePathRelative = importedExport.resolvedFilePath ?? importedExport.filePath;
+        // because that's where scenario component files are written.
+        // Map nested dist paths to src paths so import paths point to actual source files.
+        const scenarioFilePathRelative = mapNestedDistToSrc(importedExport.resolvedFilePath ?? importedExport.filePath);
         // Try looking up with different key formats (absolute, relative, resolved absolute)
         // Filter out undefined keys to avoid misleading undefined lookups
         const lookupKeys = [
@@ -820,6 +1595,25 @@ export default async function writeScenarioComponents({ project, file, entity, r
             }
             const fileName = actualScenarioFilePathRelative.split('/').pop();
             const fileNotMockedIsIndex = isIndexPath(fileNotMocked?.path);
+            // For data/type entities, use 'data' instead of entity name since we write
+            // ONE file per source file (not per entity) for data entities
+            const isDataEntity = importedExportEntity?.entityType === 'data' ||
+                importedExportEntity?.entityType === 'type';
+            const scenarioFileName = isDataEntity
+                ? 'data'
+                : safeFileName(importedExportEntity.name);
+            // For data entities, look up the SHA that was used to create the data file
+            // (stored when the file was first written). This ensures all entities from
+            // the same source file have their imports rewritten to point to the same file.
+            // Use actualScenarioFilePathRelative as the key since that's what matches
+            // importedExportFilePath used when storing (both are relative paths).
+            let entityShaForPath = importedExportEntity.sha;
+            if (isDataEntity && actualScenarioFilePathRelative) {
+                const storedShaMarker = writtenScenarioComponents[actualScenarioFilePathRelative]?.find((m) => m.startsWith('__data_file_sha__:'));
+                if (storedShaMarker) {
+                    entityShaForPath = storedShaMarker.replace('__data_file_sha__:', '');
+                }
+            }
             const mockFilePath = isFrameworkRoute(fileNotMocked, importedExportEntity, framework, fileNotMocked === rootFile)
                 ? getFrameworkRoutePath({
                     file: fileNotMocked,
@@ -834,36 +1628,57 @@ export default async function writeScenarioComponents({ project, file, entity, r
                     .split('.')
                     .slice(0, -1)
                     .join('.')
-                : actualScenarioFilePathRelative.replace(`${fileName}`, `${importedExportEntity.sha}_${fileNotMockedIsIndex ? 'index_' : ''}${safeFileName(importedExportEntity.name)}_${safeFileName(scenario.name)}`);
+                : actualScenarioFilePathRelative.replace(`${fileName}`, `${entityShaForPath}_${fileNotMockedIsIndex ? 'index_' : ''}${scenarioFileName}_${safeFileName(scenario.name)}`);
             const path = safeFolder(getRelativePath(filePath, mockFilePath));
             // If we have an import mapping, use it to find the import string to replace
             // Otherwise, skip rewriting (we can't find the import statement without knowing what to search for)
             if (mockImportMapping) {
                 const importRegExp = new RegExp(`${escapeRegExp(mockImportMapping)}(['"])`, 'g');
+                // Check if there are mocked entities from the same file
+                // If so, we can't replace the entire import path - the mocked entities will be inlined
+                // and we need to keep the original import path for this non-mocked entity
+                const sameFileImports = sortedImportedExports.filter((ie) => ie.filePath === importedExport.filePath);
+                const hasMockedSameFileImports = sameFileImports.some((ie) => ie.isMocked && ie.name !== importedExport.name);
                 // Check if the original import path still exists in the file
                 // If it was already rewritten by another entity from the same module,
                 // we need to add a separate import statement for this entity
                 if (fileContent.match(importRegExp)) {
-                    fileContent = fileContent.replace(importRegExp, `${path}$1`);
+                    if (hasMockedSameFileImports) {
+                        // There are mocked entities from the same file that will be inlined
+                        // Don't rewrite the import path - the original import is still needed for this non-mocked entity
+                        // The mocked entities will be inlined, so the original import statement will remain
+                        // with only the non-mocked entities after the mocked ones are removed
+                    }
+                    else {
+                        // No mocked entities from the same file - safe to replace entire path
+                        fileContent = fileContent.replace(importRegExp, `${path}$1`);
+                    }
                 }
                 else {
                     // The import path was already rewritten - add a new import for this entity
                     // This handles cases where multiple entities are imported from the same index file
                     // (e.g., import { A, B, C } from '@pkg') and each has its own scenario file
                     const entityImportName = importedExport.name;
-                    const newImport = `import { ${entityImportName} } from '${path}';`;
+                    // Use default import syntax for default exports, named import for named exports
+                    const newImport = importedExport.isDefault
+                        ? `import ${entityImportName} from '${path}';`
+                        : `import { ${entityImportName} } from '${path}';`;
                     // First, try to remove this entity from the already-rewritten grouped import
                     // This prevents duplicate/conflicting imports
-                    // Match patterns like "EntityName," or ", EntityName" or "EntityName" (if only one)
-                    // Note: entityImportName needs escaping since JS identifiers can contain $ (a regex metacharacter)
+                    // Use AST-based removal to properly handle type-only imports like `type EntityName`
                     const escapedEntityName = escapeRegExp(entityImportName);
-                    const removeFromGroupedImportPatterns = [
-                        new RegExp(`\\b${escapedEntityName}\\s*,\\s*`, 'g'), // "EntityName, "
-                        new RegExp(`\\s*,\\s*${escapedEntityName}\\b`, 'g'), // ", EntityName"
-                    ];
-                    for (const pattern of removeFromGroupedImportPatterns) {
-                        fileContent = fileContent.replace(pattern, '');
+                    // For default imports: remove "DefaultName, " from "import DefaultName, { ... }"
+                    // This handles the case where a default export is being split out
+                    if (importedExport.isDefault) {
+                        const defaultImportPattern = new RegExp(`(import\\s+)${escapedEntityName}\\s*,\\s*(\\{)`, 'gm');
+                        fileContent = fileContent.replace(defaultImportPattern, '$1$2');
                     }
+                    // 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
@@ -877,17 +1692,30 @@ export default async function writeScenarioComponents({ project, file, entity, r
             }
         }
     }
+    // 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 ?? [];
+    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
@@ -900,6 +1728,7 @@ export default async function writeScenarioComponents({ project, file, entity, r
         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') {
@@ -935,17 +1764,351 @@ export default async function writeScenarioComponents({ project, file, entity, r
             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);
-    console.log('Writing scenario component', file.path, entity.name, scenarioComponentPath, fileContent.length);
+    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.
+     * Uses a visited set to detect and break circular import chains.
+     *
+     * @param content - The file content to process
+     * @param sourceFilePath - The original source file path (for resolving relative imports)
+     * @param targetFilePath - The path where this content will be written (for computing relative imports)
+     * @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(), depth = 0, startTime = Date.now()) {
+        // Global timeout for entire 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,
+            visitedCount: visitedPaths.size,
+        });
+        let modifiedContent = content;
+        // 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)
+            const basePath = safeFolder(importFile.path.split('/').slice(0, -1).join('/'));
+            const extension = importFile.name.split('.').pop();
+            const isIndex = isIndexPath(importFile.path);
+            // 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
+            const alreadyProcessed = writtenScenarioComponents[resolvedPath]?.includes('__transitive_file_written__');
+            // Only create the transitive file if not circular and not already processed
+            if (!isCircularImport && !alreadyProcessed) {
+                // Load content if needed
+                if (!importFile.content && fileStore) {
+                    importFile = await fileStore.ensureContent(resolvedPath);
+                }
+                if (!importFile?.content) {
+                    // Can't create transitive, but still try to rewrite import below
+                }
+                else {
+                    // Mark as being processed BEFORE recursing (to detect cycles)
+                    visitedPaths.add(resolvedPath);
+                    // Strip server-only and mock server-only packages, then recursively process imports
+                    let transitiveContent = stripServerOnlyImport(importFile.content);
+                    transitiveContent = applyServerOnlyMocks(transitiveContent);
+                    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] = [];
+                    }
+                    writtenScenarioComponents[resolvedPath].push('__transitive_file_written__');
+                }
+            }
+            // 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, '\\$&');
+            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;
+    }
+    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"
+    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}`);
+        // Skip imports that point to generated CodeYam files (same skip logic as
+        // rewriteRelativeModuleImports). Without this, MockData files from earlier
+        // captures that get discovered by the TypeScript compiler would be treated as
+        // regular imports, creating transitive copies with stale content.
+        const scenarioFilePattern = /[a-f0-9]{64}_\w+_[A-Z]\w*$/;
+        const mockDataPattern = /__codeyamMocks__\//;
+        if (scenarioFilePattern.test(importPath) ||
+            mockDataPattern.test(importPath)) {
+            continue;
+        }
+        // Resolve the import path to a project file path
+        const resolvedFilePath = resolveImportPath(importPath, file.path, project);
+        if (!resolvedFilePath) {
+            // Can't resolve - might be a path we don't handle, skip it
+            continue;
+        }
+        // Find the file in project.files, using fileStore for O(1) lookup when available
+        // We need to find the file BEFORE checking importedExports to see if it has server-only
+        let targetFile = fileStore
+            ? fileStore.getByPath(resolvedFilePath)
+            : project.files?.find((f) => f.path === resolvedFilePath);
+        // Skip if this import is in importedExports - it's handled by the main processing loop
+        // UNLESS the file contains "server-only", in which case we still need a transitive copy
+        // with server-only stripped (even if some exports from the file are mocked).
+        if (importedExportFilePaths.has(resolvedFilePath)) {
+            // Check if the file has server-only before skipping
+            let fileContent = targetFile?.content;
+            if (!fileContent && targetFile && fileStore) {
+                // Load content to check for server-only
+                const loadedFile = await fileStore.ensureContent(resolvedFilePath);
+                fileContent = loadedFile?.content;
+                if (loadedFile) {
+                    targetFile = loadedFile;
+                }
+            }
+            const hasServerOnly = fileContent && /import\s+["']server-only["']/.test(fileContent);
+            if (!hasServerOnly) {
+                continue;
+            }
+            // File has server-only - continue processing to create transitive copy
+        }
+        if (!targetFile) {
+            continue;
+        }
+        // Compute the transformed file path (needed for import rewriting even if already processed)
+        const targetFileBasePath = safeFolder(targetFile.path.split('/').slice(0, -1).join('/'));
+        const targetFileExtension = targetFile.name.split('.').pop();
+        const targetFileIsIndex = isIndexPath(targetFile.path);
+        // 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
+        // only export specific items, so we need a full transitive copy with all exports.
+        const alreadyTransitive = writtenScenarioComponents[resolvedFilePath]?.includes('__transitive_file_written__');
+        if (!alreadyTransitive) {
+            // Ensure content is loaded (LazyFileStore loads content on-demand)
+            if (!targetFile.content && fileStore) {
+                targetFile = await fileStore.ensureContent(resolvedFilePath);
+            }
+            if (!targetFile?.content) {
+                continue;
+            }
+            // Get the file content and apply transformations
+            let transformedContent = targetFile.content;
+            transformedContent = stripServerOnlyImport(transformedContent);
+            transformedContent = applyServerOnlyMocks(transformedContent);
+            // 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;
+                // Get file info for building the transformed path
+                let nestedFile = fileStore
+                    ? fileStore.getByPath(nestedResolvedPath)
+                    : project.files?.find((f) => f.path === nestedResolvedPath);
+                if (!nestedFile)
+                    continue;
+                // Build the transformed path (needed for import rewriting even if already processed)
+                const nestedBasePath = safeFolder(nestedFile.path.split('/').slice(0, -1).join('/'));
+                const nestedExtension = nestedFile.name.split('.').pop();
+                const nestedIsIndex = isIndexPath(nestedFile.path);
+                // 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
+                const nestedAlreadyTransitive = writtenScenarioComponents[nestedResolvedPath]?.includes('__transitive_file_written__');
+                if (!nestedAlreadyTransitive) {
+                    // Ensure content is loaded for nested files
+                    if (!nestedFile.content && fileStore) {
+                        nestedFile = await fileStore.ensureContent(nestedResolvedPath);
+                    }
+                    if (!nestedFile?.content)
+                        continue;
+                    // Strip server-only, mock server-only packages, and recursively process imports
+                    // This handles chains of any depth: A -> B -> C -> D
+                    let nestedContent = stripServerOnlyImport(nestedFile.content);
+                    nestedContent = applyServerOnlyMocks(nestedContent);
+                    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
+                    if (!writtenScenarioComponents[nestedResolvedPath]) {
+                        writtenScenarioComponents[nestedResolvedPath] = [];
+                    }
+                    writtenScenarioComponents[nestedResolvedPath].push('__transitive_file_written__');
+                }
+                // Rewrite the import to point to the transitive copy
+                const nestedRelativePath = getRelativePath(transformedFilePath, nestedTransformedPath);
+                // Strip the extension before applying safeFolder - import paths in TypeScript
+                // should NOT include extensions (Next.js resolves .ts/.tsx automatically).
+                // Without this, safeFolder converts ".ts" to "_ts" causing "Module not found" errors.
+                const nestedRelativePathWithoutExt = nestedRelativePath.replace(/\.(ts|tsx|js|jsx)$/, '');
+                const safeNestedRelativePath = safeFolder(nestedRelativePathWithoutExt);
+                const escapedNestedImportPath = nestedImportPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const nestedImportRegex = new RegExp(`(from\\s*["'])${escapedNestedImportPath}(["'])`, 'g');
+                transformedContent = transformedContent.replace(nestedImportRegex, `$1${safeNestedRelativePath}$2`);
+            }
+            // Re-check if file was written during recursive processing
+            // (processTransitiveImportsRecursively might have created this file while processing
+            // a nested import that circularly imports back to this file)
+            const writtenDuringRecursion = writtenScenarioComponents[resolvedFilePath]?.includes('__transitive_file_written__');
+            if (!writtenDuringRecursion) {
+                // Write the transformed file
+                await writeFile(transformedFilePath, transformedContent);
+                scenarioComponentPaths.push(transformedFilePath);
+                // Mark as written
+                if (!writtenScenarioComponents[resolvedFilePath]) {
+                    writtenScenarioComponents[resolvedFilePath] = [];
+                }
+                writtenScenarioComponents[resolvedFilePath].push('__transitive_file_written__');
+            }
+        }
+        // ALWAYS rewrite the import in fileContent to point to the transformed file
+        // (even if the transitive copy was already created by another entity)
+        const relativePath = getRelativePath(scenarioComponentPath, transformedFilePath);
+        // Strip the extension before applying safeFolder - import paths in TypeScript
+        // should NOT include extensions (Next.js resolves .ts/.tsx automatically).
+        // Without this, safeFolder converts ".ts" to "_ts" causing "Module not found" errors.
+        const relativePathWithoutExt = relativePath.replace(/\.(ts|tsx|js|jsx)$/, '');
+        const safeRelativePath = safeFolder(relativePathWithoutExt);
+        // Escape special regex characters in the import path
+        const escapedImportPath = importPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        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 })))}
@@ -956,25 +2119,74 @@ export default async function writeScenarioComponents({ project, file, entity, r
 // 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`);
+        }
+    }
+    // For route components (page.tsx, layout.tsx), the component IS the Next.js page.
+    // There's no wrapper page to inject argumentsData as props (unlike non-route components
+    // which get a scenarioComponent wrapper). We need to wrap the default export so that
+    // the scenario's argumentsData is passed as props to the component.
+    if (isFrameworkRoute(file, entity, framework, file === rootFile) &&
+        rootAnalysis.metadata?.scenariosDataStructure?.arguments?.length > 0) {
+        const positionalArguments = rootAnalysis.metadata.scenariosDataStructure.arguments;
+        const hasNamedArgs = positionalArguments.length === 1 &&
+            typeof positionalArguments[0] === 'object';
+        if (hasNamedArgs) {
+            // Match: export default function Name(
+            // Also: export default async function Name(
+            const defaultExportMatch = fileContent.match(/export\s+default\s+(async\s+)?function\s+(\w+)\s*\(/);
+            if (defaultExportMatch) {
+                const funcName = defaultExportMatch[2];
+                // Remove "export default" from the original function declaration
+                fileContent = fileContent.replace(/export\s+default\s+(async\s+)?function\s+(\w+)\s*\(/, '$1function $2(');
+                // Ensure scenarios import is present
+                const mockDataPath = `${relativeMocksDir}/MockData_${safeFileName(scenario.name)}`;
+                if (fileContent.indexOf('import { scenarios } from') === -1) {
+                    fileContent = `import { scenarios } from "${mockDataPath}";\n\n${fileContent}`;
+                }
+                // Add wrapper default export that injects argumentsData as props
+                fileContent += `\n\nexport default function _CYRouteWrapper(props: any) {
+  const _cyArgs = scenarios().data()?.['arguments']?.[0] ?? {};
+  return <${funcName} {...props} {..._cyArgs} />;
+}\n`;
+            }
+        }
+    }
     // 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.
+    // Server action files get mocked with objects that aren't async functions,
+    // which would violate Next.js's "use server" requirement:
+    // "A 'use server' file can only export async functions, found object."
     let finalContent;
-    if (extractedDirective) {
+    if (extractedDirective && extractedDirective.includes('client')) {
         finalContent = `${extractedDirective}\n\n${scenarioComponentComment}\n\n${fileContent}`;
-        console.log(`CodeYam: Placed "${extractedDirective}" directive at top of file: ${scenarioComponentPath}`);
     }
     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);
-    console.log('CodeYam [writeScenarioComponents]: Generated scenario files', {
-        entityName: entity.name,
-        filePath: file.path,
-        scenarioName: scenario.name,
-        scenarioComponentPathsGenerated: scenarioComponentPaths,
-        writtenScenarioComponentKeys: Object.keys(writtenScenarioComponents),
-    });
+    console.log(`[WriteScenario] POST-LOOP ${entity.name}: COMPLETE total=${Date.now() - postLoopStartTime}ms`);
     return { scenarioComponentPaths, writtenScenarioComponents };
 }
 //# sourceMappingURL=writeScenarioComponents.js.map