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

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

@@ -1,16 +1,220 @@
+import { ProjectFramework, } from "../../../../../packages/types/index.js";
 import writeFile from "../common/writeFile.js";
 import { isFrameworkRoute, getFrameworkRoutePath, safeFileName, PROJECT_RELATIVE_PATH, } from "../../../../../packages/utils/index.js";
 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 {
+        const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
+        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.
+ */
+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;
     }
-    return !!constructMockCode(importedExport.name, fileAnalyses.find((a) => !!a.metadata?.mergedDataStructure?.dependencySchemas?.[importedExport.filePath]?.[importedExport.name])?.metadata?.mergedDataStructure?.dependencySchemas);
+    return !!constructMockCode(importedExport.name, fileAnalyses.find((a) => !!a.metadata?.mergedDataStructure?.dependencySchemas?.[importedExport.filePath]?.[importedExport.name])?.metadata?.mergedDataStructure?.dependencySchemas, importedExport.entityType);
 }
 function isIndexPath(filePath) {
     if (!filePath)
@@ -18,6 +222,55 @@ function isIndexPath(filePath) {
     const fileName = filePath.split('/').pop();
     return fileName.startsWith('index.');
 }
+/**
+ * Convert .d.ts type declaration content to stub implementations.
+ * .d.ts files only have type declarations which don't provide runtime exports.
+ * This function converts them to actual stub implementations.
+ *
+ * @param content - The .d.ts file content
+ * @param entityName - The name of the entity we're generating for (used to ensure it's exported)
+ * @returns The converted content with stub implementations
+ */
+function convertDtsToStubs(content, entityName) {
+    let result = content;
+    // Handle object types FIRST (before simple types) since they span multiple lines
+    // and contain semicolons that would incorrectly terminate the simple type regex
+    // Convert "export declare const NAME: { ... };" (object type) to "export const NAME = {} as any;"
+    result = result.replace(/export\s+declare\s+const\s+(\w+)\s*:\s*\{[^}]*\}\s*;/gs, 'export const $1 = {} as any;');
+    // Convert "export declare let NAME: { ... };" (object type) to "export let NAME = {} as any;"
+    result = result.replace(/export\s+declare\s+let\s+(\w+)\s*:\s*\{[^}]*\}\s*;/gs, 'export let $1 = {} as any;');
+    // Convert "export declare var NAME: { ... };" (object type) to "export var NAME = {} as any;"
+    result = result.replace(/export\s+declare\s+var\s+(\w+)\s*:\s*\{[^}]*\}\s*;/gs, 'export var $1 = {} as any;');
+    // Now handle simple types (non-object types)
+    // Convert "export declare const NAME: TYPE;" to "export const NAME = {} as any;"
+    result = result.replace(/export\s+declare\s+const\s+(\w+)\s*:\s*[^;]+;/g, 'export const $1 = {} as any;');
+    // Convert "export declare let NAME: TYPE;" to "export let NAME = {} as any;"
+    result = result.replace(/export\s+declare\s+let\s+(\w+)\s*:\s*[^;]+;/g, 'export let $1 = {} as any;');
+    // Convert "export declare var NAME: TYPE;" to "export var NAME = {} as any;"
+    result = result.replace(/export\s+declare\s+var\s+(\w+)\s*:\s*[^;]+;/g, 'export var $1 = {} as any;');
+    // Convert "export declare function NAME(...): TYPE;" to "export function NAME() { return {} as any; }"
+    result = result.replace(/export\s+declare\s+function\s+(\w+)\s*\([^)]*\)\s*:\s*[^;]+;/g, 'export function $1(...args: any[]) { return {} as any; }');
+    // Convert "export declare class NAME { ... }" to "export class NAME {}"
+    // This is tricky because class bodies can span multiple lines
+    result = result.replace(/export\s+declare\s+class\s+(\w+)\s*(?:extends\s+[^{]+)?\{[^}]*\}/gs, 'export class $1 {}');
+    // Convert "declare const NAME: { ... }" (object type, non-exported) to "const NAME = {} as any;"
+    // Object types can span multiple lines and contain semicolons, so we handle them separately
+    // The 's' flag makes . match newlines, so this matches the entire object type block
+    result = result.replace(/^declare\s+const\s+(\w+)\s*:\s*\{[^}]*\}\s*;/gms, 'const $1 = {} as any;');
+    // Convert "declare const NAME: TYPE;" (simple type, non-exported) to "const NAME = {} as any;"
+    // These are often used with "export { NAME }" at the end
+    // This must come AFTER the object type handler above
+    result = result.replace(/^declare\s+const\s+(\w+)\s*:\s*[^;]+;/gm, 'const $1 = {} as any;');
+    // Convert "declare function NAME" (non-exported) to "function NAME() { return {} as any; }"
+    result = result.replace(/^declare\s+function\s+(\w+)\s*\([^)]*\)\s*:\s*[^;]+;/gm, 'function $1(...args: any[]) { return {} as any; }');
+    // Convert "declare class NAME" (non-exported) to "class NAME {}"
+    result = result.replace(/^declare\s+class\s+(\w+)\s*(?:extends\s+[^{]+)?\{[^}]*\}/gm, 'class $1 {}');
+    // Remove "export { }" at the end (empty export statement that marks module as having no exports)
+    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
+    return result;
+}
 /**
  * Rewrite relative asset paths to correct locations when a file is moved.
  *
@@ -59,6 +312,275 @@ function rewriteAssetImports(fileContent, originalFilePath, newFilePath) {
         return `${quote}${newRelativePath}${quote}`;
     });
 }
+/**
+ * Rewrite relative TypeScript/JavaScript module imports when a file is moved.
+ *
+ * When a file is moved from one location to another (e.g., from [environmentId]/
+ * to _environmentId_/), relative imports like "./lib/organization" need to be
+ * rewritten to point to the correct location from the new path.
+ *
+ * This is similar to rewriteAssetImports but handles TypeScript/JavaScript modules
+ * instead of asset files (CSS, images, etc.).
+ */
+function rewriteRelativeModuleImports(fileContent, originalFilePath, newFilePath) {
+    // Module file extensions that should have their relative paths rewritten
+    const moduleExtensions = 'ts|tsx|js|jsx|mjs|cjs';
+    // Match import statements with relative paths (starting with ./ or ../)
+    // This matches:
+    // - import { foo } from "./path.js"
+    // - import foo from "../path.js"
+    // - import * as foo from "./path/index.js"
+    // - import "./path" (side-effect imports)
+    // The path may or may not have a file extension
+    const relativeImportRegex = new RegExp(`(from\\s+)(['"])(\\.\\.?\\/[^'"]+?)(?:\\.(?:${moduleExtensions}))?\\2`, 'g');
+    // Get the directory part of the original file path (relative to project root)
+    const originalDirParts = originalFilePath.split('/').slice(0, -1);
+    return fileContent.replace(relativeImportRegex, (match, fromKeyword, quote, importPath) => {
+        // 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]\w*$/;
+        const mockDataPattern = /__codeyamMocks__\//;
+        if (scenarioFilePattern.test(importPath) ||
+            mockDataPattern.test(importPath)) {
+            // This import already points to a generated file, don't rewrite it
+            return match;
+        }
+        // Resolve the import path relative to the original file's directory
+        const pathParts = importPath.split('/');
+        const resolvedParts = [...originalDirParts];
+        for (const part of pathParts) {
+            if (part === '..') {
+                resolvedParts.pop();
+            }
+            else if (part !== '.') {
+                resolvedParts.push(part);
+            }
+        }
+        // Build the project-relative path to the module
+        const absoluteModulePath = resolvedParts.join('/');
+        // Calculate the new relative path from new file location
+        const newRelativePath = getRelativePath(newFilePath, absoluteModulePath);
+        // Replace the path in the original match, preserving the quote style
+        return `${fromKeyword}${quote}${newRelativePath}${quote}`;
+    });
+}
+/**
+ * Strip <html> and <body> tags from root layout files for Next.js App Router.
+ *
+ * When a root layout (app/layout.tsx) is generated as a scenario component and placed
+ * under the /static/ route, it becomes nested under the real app root layout. Having
+ * two layouts with <html> and <body> tags causes hydration errors:
+ *
+ *   "In HTML, <html> cannot be a child of <body>"
+ *   "You are mounting a new html component when a previous one has not first unmounted"
+ *
+ * This function removes the <html> and <body> wrapper tags while preserving the inner
+ * content, allowing the scenario layout to work correctly when nested.
+ *
+ * Before: <html lang="en"><body className={...}><main>{children}</main></body></html>
+ * After:  <div className={...}><main>{children}</main></div>
+ */
+function stripHtmlBodyTags(fileContent, filePath, framework) {
+    // Only apply to Next.js App Router root layouts
+    if (framework !== ProjectFramework.Next) {
+        return fileContent;
+    }
+    // Check if this is a root layout file (typically app/layout.tsx or apps/*/app/layout.tsx)
+    // Root layouts are at the app directory level, not in subdirectories like (app)/ or routes/
+    const pathParts = filePath.split('/');
+    const fileName = pathParts[pathParts.length - 1];
+    // Must be a layout file
+    if (!fileName?.startsWith('layout.')) {
+        return fileContent;
+    }
+    // Check if it's at the app root level (parent directory is 'app')
+    const parentDir = pathParts[pathParts.length - 2];
+    if (parentDir !== 'app') {
+        return fileContent;
+    }
+    // Check if this file actually contains <html> and <body> tags
+    if (!/<html[^>]*>/.test(fileContent) || !/<body[^>]*>/.test(fileContent)) {
+        return fileContent;
+    }
+    // Extract the body className/attributes if any, to preserve styling
+    const bodyMatch = fileContent.match(/<body([^>]*)>/);
+    const bodyAttributes = bodyMatch?.[1]?.trim() || '';
+    // Replace the JSX structure:
+    // <html ...><body ...>CONTENT</body></html>
+    // With: <div ...>CONTENT</div>
+    //
+    // This regex handles:
+    // 1. Opening <html> tag with any attributes
+    // 2. Opening <body> tag with any attributes (captured for the wrapper div)
+    // 3. Content between body tags (captured)
+    // 4. Closing </body> and </html> tags
+    const htmlBodyRegex = /(<html[^>]*>\s*<body)([^>]*)(>)([\s\S]*?)(<\/body>\s*<\/html>)/g;
+    let result = fileContent.replace(htmlBodyRegex, (match, _htmlBody, bodyAttrs, closeBracket, content, _closing) => {
+        // Create a wrapper div with the body's attributes
+        const attrs = bodyAttrs?.trim() || '';
+        if (attrs) {
+            return `(<div${bodyAttrs}${closeBracket}${content}</div>)`;
+        }
+        else {
+            return `(<>${content}</>)`;
+        }
+    });
+    // If the regex didn't match (perhaps due to different formatting),
+    // try a more lenient approach - just remove the tags
+    if (result === fileContent) {
+        // Remove <html ...> opening tag
+        result = result.replace(/<html[^>]*>\s*/g, '');
+        // Remove </html> closing tag
+        result = result.replace(/\s*<\/html>/g, '');
+        // Replace <body ...> with <div ...> to preserve attributes
+        result = result.replace(/<body([^>]*)>/g, '<div$1>');
+        // Replace </body> with </div>
+        result = result.replace(/<\/body>/g, '</div>');
+    }
+    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 {
+        const sourceFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.Latest, true);
+        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;
@@ -68,21 +590,170 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
         dependencySchemas =
             rootAnalysis.metadata?.mergedDataStructure?.dependencySchemas;
     }
-    const mockCode = constructMockCode(importedExport.name, dependencySchemas);
-    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
+    const hasMultipleCallsWithVariables = importedExport.calls &&
+        importedExport.calls.length > 1 &&
+        importedExport.callVariableNames &&
+        importedExport.callVariableNames.length === importedExport.calls.length;
+    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 canonical keys for this hook (sorted by index)
+        const dataForMocks = rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
+        const canonicalKeysForHook = dataForMocks
+            ? Object.keys(dataForMocks)
+                .filter((key) => {
+                const match = key.match(/^[^:]+::([^:]+)::\d+$/);
+                return match && match[1] === importedExport.name;
+            })
+                .sort((a, b) => {
+                // Sort by the index part (last ::N)
+                const indexA = parseInt(a.split('::').pop() || '0');
+                const indexB = parseInt(b.split('::').pop() || '0');
+                return indexA - indexB;
+            })
+            : [];
+        // Track variable name occurrences for unique function naming
+        const variableNameCounts = {};
+        for (let i = 0; i < importedExport.calls.length; 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 canonical key at index i if available
+            const canonicalKey = canonicalKeysForHook[i];
+            // Use variable-qualified format that constructMockCode understands
+            // e.g., "entityDiffFetcher <- useFetcher" for schema lookup
+            // This generates unique variable names like useFetcher_entityDiffFetcherReturnValue
+            const qualifiedMockName = `${indexedVariableName} <- ${importedExport.name}`;
+            // Generate mock code using the variable-qualified name and canonical key for data lookup
+            // This prevents "symbol already declared" errors when multiple calls exist
+            const variableMockCode = constructMockCode(qualifiedMockName, // Use variable-qualified format for unique naming
+            dependencySchemas, importedExport.entityType, canonicalKey);
+            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()
+                const callSignature = importedExport.calls[i];
+                // Escape special regex characters in the call signature
+                const escapedCallSignature = callSignature.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                // Create regex that matches the call (with optional whitespace variations)
+                const callRegex = new RegExp(escapedCallSignature.replace(/\s+/g, '\\s*'), 'g');
+                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, look up canonical key from dataForMocks
+            const dataForMocks = rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
+            let canonicalKey = dataForMocks
+                ? Object.keys(dataForMocks).find((key) => {
+                    // Check canonical key format: EntityName::hookName::index
+                    const canonicalMatch = key.match(/^[^:]+::([^:]+)::\d+$/);
+                    if (canonicalMatch && canonicalMatch[1] === importedExport.name) {
+                        return true;
+                    }
+                    // Fall back to legacy format
+                    const legacyMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*<-\s*(.+)$/);
+                    return legacyMatch && legacyMatch[2] === importedExport.name;
+                })
+                : undefined;
+            // If no canonical key found in dataForMocks, use variable-qualified format directly
+            // This allows constructMockCode to find the schema in dependencySchemas
+            if (!canonicalKey) {
+                canonicalKey = `${singleCallVariableName} <- ${importedExport.name}`;
+            }
+            // Keep the original function name since there's only one call
+            mockCode = constructMockCode(importedExport.name, dependencySchemas, importedExport.entityType, canonicalKey, { keepOriginalFunctionName: true });
+            // If constructMockCode didn't generate code, fall back to simple return
+            if (!mockCode) {
+                mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${canonicalKey}"];
+
+function ${importedExport.name}() {
+  return ${importedExport.name}ReturnValue;
+}`;
+            }
+        }
+        else {
+            // Look for canonical key (format: EntityName::hookName::index) or legacy variable-qualified key
+            let canonicalKey;
+            // Helper to find matching key from dataForMocks
+            const findMatchingKey = (dataForMocks) => {
+                if (!dataForMocks)
+                    return undefined;
+                return Object.keys(dataForMocks).find((key) => {
+                    // Check canonical key format: EntityName::hookName::index
+                    const canonicalMatch = key.match(/^[^:]+::([^:]+)::\d+$/);
+                    if (canonicalMatch && canonicalMatch[1] === importedExport.name) {
+                        return true;
+                    }
+                    // Fall back to legacy variable-qualified format: variableName <- functionName
+                    const legacyMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*<-\s*(.+)$/);
+                    return legacyMatch && legacyMatch[2] === importedExport.name;
+                });
+            };
+            // CRITICAL: Check rootAnalysis FIRST for canonical keys.
+            // This ensures we use the same keys that will be in the mock DATA.
+            // The mock DATA is generated from rootAnalysis, so the mock CODE must
+            // also use rootAnalysis keys to ensure the lookup succeeds.
+            // Bug scenario (if we check fileAnalyses first):
+            //   - Child component's fileAnalysis has: "ChildComponent::hook::0"
+            //   - Root's dataForMocks has: "RootEntity::hook::0"
+            //   - Mock CODE uses child key, but mock DATA has root key → lookup fails
+            canonicalKey = findMatchingKey(rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks);
+            // If not found in rootAnalysis, fall back to fileAnalyses
+            if (!canonicalKey) {
+                for (const analysis of fileAnalyses) {
+                    canonicalKey = findMatchingKey(analysis.metadata?.scenariosDataStructure?.dataForMocks);
+                    if (canonicalKey)
+                        break;
+                }
+            }
+            if (canonicalKey) {
+                // Use the canonical key for data lookup
+                // Keep the original function name since there's only one call
+                mockCode = constructMockCode(importedExport.name, dependencySchemas, importedExport.entityType, canonicalKey, { keepOriginalFunctionName: true });
+                // If constructMockCode didn't generate code, fall back to simple return
+                if (!mockCode) {
+                    mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${canonicalKey}"];
+
+function ${importedExport.name}() {
+  return ${importedExport.name}ReturnValue;
+}`;
+                }
+            }
+            else {
+                // Original behavior for calls without variable names
+                mockCode = constructMockCode(importedExport.name, dependencySchemas, importedExport.entityType);
+            }
+        }
+    }
+    // Combine all mock codes
+    const allMockCodes = variableMockCodes.length > 0 ? variableMockCodes.join('\n\n') : mockCode;
+    if (!allMockCodes) {
         return fileContent;
     }
     if (importPath) {
@@ -93,7 +764,9 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
             fileContent = fileContent.replace(entireImportRegExp, '');
         }
         else {
-            const importRegExp = new RegExp(`(import(?:(?!${firstPart}|from|import)[\\s\\S])*?)${firstPart}(?:,\\s*)?((?:(?!import)[\\s\\S])*?from\\s+['"]${importPath}['"])`, 'm');
+            // 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) {
                 fileContent = fileContent.replace(importRegExp, `$1${firstPart}__cyOriginal$2`);
             }
@@ -105,13 +778,49 @@ function addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysi
             fileContent = fileContent.replace(/import\s*\{\s*\}\s*from\s+['"][^'"]*['"];?\s*\n?/g, '');
         }
     }
+    else {
+        // Fallback: When importPath is undefined (e.g., path alias not in mapping),
+        // we still need to remove the import to avoid "name defined multiple times" errors.
+        // Search for the entity name in any import statement and remove it.
+        const importedExportNameParts = splitOutsideParenthesesAndArrays(importedExport.name);
+        const firstPart = importedExportNameParts[0];
+        // Match the entity name in any named import and remove just that name
+        // This handles imports like: import { useEnvironment, otherThing } from "any/path"
+        // Removes useEnvironment but keeps otherThing
+        const namedImportRegExp = new RegExp(`(import\\s*\\{[^}]*?)\\b${escapeRegExp(firstPart)}\\b(?:,\\s*|\\s*,)?((?:[^}]*\\}\\s*from\\s*['"][^'"]*['"];?))`, 'm');
+        if (importedExportNameParts.length > 1) {
+            // Rename the import instead of removing (for destructured access patterns)
+            fileContent = fileContent.replace(namedImportRegExp, `$1${firstPart}__cyOriginal$2`);
+        }
+        else {
+            fileContent = fileContent.replace(namedImportRegExp, '$1$2');
+        }
+        // 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
@@ -256,6 +965,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,
@@ -324,6 +1041,47 @@ export default async function writeScenarioComponents({ project, file, entity, r
     const nodeModuleImports = allImportedExports.filter((nodeModuleImport, index, self) => nodeModuleImport.isNodeModule &&
         index === self.findIndex((nmi) => nmi.name === nodeModuleImport.name));
     let fileContent = file.content;
+    // Handle .d.ts files: convert type declarations to stub implementations
+    // .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')) {
+        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
+    const directiveMatch = fileContent.match(/^(\s*["']use (client|server)["'];?\s*\n?)/);
+    let extractedDirective = null;
+    if (directiveMatch) {
+        extractedDirective = directiveMatch[1].trim();
+        // Remove the directive from fileContent - we'll add it back at the very end
+        fileContent = fileContent.slice(directiveMatch[0].length);
+    }
     const fileAnalyzer = projectAnalyzer.getFileAnalyzer(file);
     const importMapping = fileAnalyzer.getRelativeImportMappings();
     let filePath = file.path;
@@ -358,7 +1116,20 @@ export default async function writeScenarioComponents({ project, file, entity, r
             return 1;
         return 0;
     });
+    debugLog('Starting main importedExports loop', {
+        count: sortedImportedExports.length,
+        fileContentLength: fileContent.length,
+    });
+    let importedExportIndex = 0;
     for (const importedExport of sortedImportedExports) {
+        importedExportIndex++;
+        if (importedExportIndex % 5 === 0 || importedExportIndex === 1) {
+            debugLog(`Processing importedExport ${importedExportIndex}/${sortedImportedExports.length}`, {
+                name: importedExport.name,
+                filePath: importedExport.filePath,
+                isMocked: importedExport.isMocked,
+            });
+        }
         // IMPORTANT: The import mapping keys may be either absolute or relative paths
         // depending on how they were created by the file analyzer. We try multiple formats.
         // Also need to normalize paths to handle /tmp vs /private/tmp on macOS
@@ -371,44 +1142,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)
@@ -434,52 +1203,133 @@ 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;
+                        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,
+                        }), 60000);
+                        debugLog(`Completed recursive writeScenarioComponents for ${importedExportEntity.name}`);
+                        writtenScenarioComponents = updatedWrittenScenarioComponents;
+                        scenarioComponentPaths.push(...newScenarioComponentPaths);
+                    }
                 }
             }
         }
         else if (importedExport.filePath === file.path &&
             importedExport.name !== entity.name) {
             // For same-file dependencies:
-            // - Strip if isMocked is true (e.g., Remix/Next loaders, server-side code)
-            // - Strip if we have a mock structure we can generate
-            // - Only add mock code if we have a mock structure
-            const shouldStrip = importedExport.isMocked ||
-                hasMockStructure(importedExport, fileAnalyses);
-            if (shouldStrip) {
+            // - Strip and replace if we have a mock structure we can generate
+            // - Strip and stub if isMocked is true AND it's a callable entity (visual, library, functionCall)
+            // - Preserve as-is for data entities (like Zod schemas) that need their methods
+            const hasMock = hasMockStructure(importedExport, fileAnalyses);
+            const entityType = importedExport.entityType;
+            // 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));
+            // Callable entities can be safely stubbed (but not Zod schemas)
+            const isCallable = !isDataEntity && !looksLikeZodSchema && entityType !== undefined;
+            // Determine what action to take
+            const shouldStripAndReplace = hasMock;
+            const shouldStripAndStub = !hasMock && importedExport.isMocked && isCallable;
+            const shouldPreserve = !hasMock && importedExport.isMocked && !isCallable;
+            // Log warning if entityType is undefined for a mocked same-file dependency
+            // This could indicate an analysis issue where entityType wasn't properly set
+            if (importedExport.isMocked && entityType === undefined) {
+                console.warn(`CodeYam: WARNING - Same-file dependency "${importedExport.name}" is isMocked but has no entityType. ` +
+                    `Treating as non-callable (will preserve). File: ${file.path}`);
+            }
+            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
+                // 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, '');
-                }
-                // Only add mock if we have a mock structure to generate
-                if (hasMockStructure(importedExport, fileAnalyses)) {
+                if (shouldStripAndReplace) {
+                    if (entityCode) {
+                        fileContent = fileContent.replace(entityCode, '');
+                    }
+                    // Add mock from mock structure
                     fileContent = addMockToContent(fileContent, importedExport, fileAnalyses, rootAnalysis, relativeMocksDir, scenario.name);
                 }
-                else if (importedExport.isMocked) {
-                    // No mock structure available, but isMocked is true.
+                else if (shouldStripAndStub) {
                     // Generate a simple stub mock that returns scenario data.
                     // This prevents ReferenceError at runtime when the stripped
                     // function is called (e.g., local helper functions like getInitialProps).
@@ -490,9 +1340,38 @@ export default async function writeScenarioComponents({ project, file, entity, r
                         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}`;
+                    }
                 }
             }
         }
@@ -502,8 +1381,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 = [
@@ -563,6 +1443,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,
@@ -577,34 +1476,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(`${mockImportMapping.replace(/([$()])/g, '\\$1')}(['"])`, 'g');
+                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)
-                    const removeFromGroupedImportPatterns = [
-                        new RegExp(`\\b${entityImportName}\\s*,\\s*`, 'g'), // "EntityName, "
-                        new RegExp(`\\s*,\\s*${entityImportName}\\b`, 'g'), // ", EntityName"
-                    ];
-                    for (const pattern of removeFromGroupedImportPatterns) {
-                        fileContent = fileContent.replace(pattern, '');
+                    // Use AST-based removal to properly handle type-only imports like `type EntityName`
+                    const escapedEntityName = escapeRegExp(entityImportName);
+                    // For default imports: remove "DefaultName, " from "import DefaultName, { ... }"
+                    // This handles the case where a default export is being split out
+                    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
@@ -618,22 +1540,32 @@ export default async function writeScenarioComponents({ project, file, entity, r
             }
         }
     }
+    // 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 pattern as applyUniversalMocks
-        const safeFileName = originalPath.replace(/[^a-zA-Z0-9_\-./]/g, '_');
-        const mockFileRelativePath = `${relativeMocksDir}/${safeFileName}`;
+        // Create the mock file name using the same safeFileName function as writeUniversalMocks
+        const safeMockFileName = safeFileName(originalPath);
+        const mockFileRelativePath = `${relativeMocksDir}/${safeMockFileName}`;
         // Match both single and double quotes, and handle both named and default imports
         // Pattern 1: import { x, y } from "module"
         // Pattern 2: import x from "module"
@@ -676,10 +1608,328 @@ 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);
-    console.log('Writing scenario component', file.path, entity.name, scenarioComponentPath, fileContent.length);
+    debugLog('Completed rewriteAssetImports');
+    // Rewrite relative TypeScript/JavaScript module imports to correct relative paths
+    // This handles cases where the file is moved (e.g., from [environmentId]/ to _environmentId_/)
+    // and relative imports like "./lib/organization" need to be rewritten
+    debugLog('Starting rewriteRelativeModuleImports');
+    fileContent = rewriteRelativeModuleImports(fileContent, `${PROJECT_RELATIVE_PATH}/${file.path}`, scenarioComponentPath);
+    debugLog('Completed rewriteRelativeModuleImports');
+    /**
+     * Recursively process a file's imports to create transitive copies with server-only stripped.
+     * This handles chains of arbitrary depth: A -> B -> C -> D where each needs server-only removed.
+     * 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 = 60000; // 1 minute max for all transitive processing
+        const elapsed = Date.now() - startTime;
+        if (elapsed > GLOBAL_TIMEOUT_MS) {
+            throw new Error(`processTransitiveImportsRecursively exceeded ${GLOBAL_TIMEOUT_MS}ms (elapsed: ${elapsed}ms) at depth=${depth} for ${sourceFilePath}`);
+        }
+        const importPaths = extractInternalImportPaths(content);
+        debugLog(`processTransitiveImportsRecursively depth=${depth}`, {
+            sourceFilePath,
+            importCount: importPaths.length,
+            visitedCount: visitedPaths.size,
+        });
+        let modifiedContent = content;
+        // 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);
+            const pathHash = safeFileName(importFile.path);
+            const transitiveFilePath = `${PROJECT_RELATIVE_PATH}/${basePath}/${pathHash}_${isIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${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;
+    }
+    // Process remaining internal imports that weren't in importedExports
+    // This handles transitive dependencies: when the file content includes code (e.g., from
+    // other functions in the same file) that imports from files with "server-only"
+    debugLog('Extracting remaining import paths');
+    const remainingImportPaths = extractInternalImportPaths(fileContent);
+    debugLog('Found remaining import paths', {
+        count: remainingImportPaths.length,
+    });
+    // Get all file paths that are in importedExports - these are handled by main processing
+    const importedExportFilePaths = new Set(allImportedExports.map((ie) => ie.resolvedFilePath || ie.filePath));
+    debugLog('Starting remaining imports loop', {
+        remainingCount: remainingImportPaths.length,
+        importedExportCount: importedExportFilePaths.size,
+    });
+    let remainingImportIndex = 0;
+    debugLog(`[REMAINING] Starting remaining imports loop, ${remainingImportPaths.length} imports`);
+    for (const importPath of remainingImportPaths) {
+        remainingImportIndex++;
+        debugLog(`[REMAINING LOOP] import ${remainingImportIndex}/${remainingImportPaths.length}: ${importPath}`);
+        // Resolve the import path to a project file path
+        const resolvedFilePath = resolveImportPath(importPath, file.path, project);
+        if (!resolvedFilePath) {
+            // 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);
+        const filePathHash = safeFileName(targetFile.path);
+        const transformedFilePath = `${PROJECT_RELATIVE_PATH}/${targetFileBasePath}/${filePathHash}_${targetFileIsIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${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);
+                const nestedPathHash = safeFileName(nestedFile.path);
+                const nestedTransformedPath = `${PROJECT_RELATIVE_PATH}/${nestedBasePath}/${nestedPathHash}_${nestedIsIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${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`);
+    }
     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 })))}
@@ -690,15 +1940,26 @@ export default async function writeScenarioComponents({ project, file, entity, r
 // Entity: ${rootAnalysis.entitySha} ${rootAnalysis.entityName}
 // Scenario: ${scenario.id} - ${scenario.name}
 `;
-    await writeFile(scenarioComponentPath, `${scenarioComponentComment}\n\n${fileContent}`);
-    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),
+    // 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 && extractedDirective.includes('client')) {
+        finalContent = `${extractedDirective}\n\n${scenarioComponentComment}\n\n${fileContent}`;
+    }
+    else {
+        finalContent = `${scenarioComponentComment}\n\n${fileContent}`;
+    }
+    debugLog('About to write final scenario file', {
+        scenarioComponentPath,
+        contentLength: finalContent.length,
     });
+    await writeFile(scenarioComponentPath, finalContent);
+    debugLog('Successfully wrote scenario file');
+    scenarioComponentPaths.push(scenarioComponentPath);
     return { scenarioComponentPaths, writtenScenarioComponents };
 }
 //# sourceMappingURL=writeScenarioComponents.js.map