@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

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

@@ -1,16 +1,75 @@
+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";
+/**
+ * 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, '\\$&');
+}
+/**
+ * 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)
@@ -19,27 +78,80 @@ function isIndexPath(filePath) {
     return fileName.startsWith('index.');
 }
 /**
- * Rewrite asset imports (CSS, images, fonts, etc.) to correct relative paths.
- * These imports aren't tracked as importedExports, so we need to handle them separately.
+ * 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.
  *
- * Handles patterns like:
+ * @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.
+ *
+ * This function generically handles ANY string literal containing a relative path
+ * to an asset file, not just import statements. This catches patterns like:
  * - import "./globals.css"
  * - import styles from "./file.module.css.js"
- * - import logo from "./logo.png.js"
+ * - localFont({ src: "../fonts/font.woff2" })
+ * - Image src="../images/logo.png"
+ * - Any other string literal with a relative asset path
  */
 function rewriteAssetImports(fileContent, originalFilePath, newFilePath) {
-    // Match imports with non-JS/TS extensions
+    // Asset file extensions that should have their paths rewritten
     const assetExtensions = 'css|scss|sass|less|styl|png|jpg|jpeg|gif|svg|webp|ico|woff|woff2|ttf|eot|otf|mp4|webm|json';
-    const assetImportRegex = new RegExp(`import\\s+(?:[\\w$]+\\s+from\\s+)?(['"])(\\.{1,2}/[^'"]+\\.(?:${assetExtensions}))\\1`, 'g');
+    // Match ANY string literal containing a relative path to an asset file
+    // This captures both single and double quoted strings that start with ./ or ../
+    const relativeAssetPathRegex = new RegExp(`(['"])(\\.{1,2}/[^'"]*\\.(?:${assetExtensions}))\\1`, 'g');
     // Get the directory part of the original file path (relative to project root)
     const originalDirParts = originalFilePath.split('/').slice(0, -1);
-    return fileContent.replace(assetImportRegex, (match, quote, importPath) => {
+    return fileContent.replace(relativeAssetPathRegex, (match, quote, assetPath) => {
         // Resolve the asset path relative to the original file's directory
         // We need to manually resolve the relative path without using path.resolve
         // which would resolve against the actual filesystem
-        const importParts = importPath.split('/');
+        const pathParts = assetPath.split('/');
         const resolvedParts = [...originalDirParts];
-        for (const part of importParts) {
+        for (const part of pathParts) {
             if (part === '..') {
                 resolvedParts.pop();
             }
@@ -51,10 +163,265 @@ function rewriteAssetImports(fileContent, originalFilePath, newFilePath) {
         const absoluteAssetPath = resolvedParts.join('/');
         // Calculate the new relative path from new file location
         const newRelativePath = getRelativePath(newFilePath, absoluteAssetPath);
-        // Reconstruct the import statement
-        return match.replace(importPath, newRelativePath);
+        // Replace the path in the original match, preserving the quote style
+        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) {
+    const importPaths = [];
+    // Match import statements with their paths
+    // Handles: import x from "path", import { x } from "path", import * as x from "path"
+    const importRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*,?\s*)*\s*from\s*["']([^"']+)["']/g;
+    let match;
+    while ((match = importRegex.exec(fileContent)) !== null) {
+        const importPath = match[1];
+        // Skip node_modules imports (bare specifiers)
+        // Internal imports start with '.', '@/', '~/' or similar path aliases
+        if (importPath.startsWith('.') ||
+            importPath.startsWith('@/') ||
+            importPath.startsWith('~/') ||
+            importPath.startsWith('#')) {
+            importPaths.push(importPath);
+        }
+    }
+    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;
@@ -64,21 +431,128 @@ 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
+        // Track variable name occurrences to disambiguate when same variable is reused
+        // (mirrors the logic in gatherDataForMocks)
+        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;
+            // If this is a reused variable name (occurrence > 0), append index
+            // e.g., "fetcher[1] <- useFetcher" for the second usage of "fetcher"
+            const indexedVariableName = occurrence > 0 ? `${variableName}[${occurrence}]` : variableName;
+            // Generate mock code for this specific call using variable-qualified name
+            // Format: "variableName <- functionName" (reads as "variableName receives from functionName")
+            const qualifiedName = `${indexedVariableName} <- ${importedExport.name}`;
+            const variableMockCode = constructMockCode(qualifiedName, dependencySchemas, importedExport.entityType);
+            if (variableMockCode) {
+                variableMockCodes.push(variableMockCode);
+                // Replace the call site with the variable-specific mock function
+                // e.g., useFetcher<BranchEntityDiffResult>() -> useFetcher_entityDiffFetcher()
+                // e.g., useFetcher() -> useFetcher_reportFetcher()
+                // For indexed variables: useFetcher() -> useFetcher_fetcher_1()
+                const callSignature = importedExport.calls[i];
+                // Escape special regex characters in the call signature
+                const escapedCallSignature = callSignature.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                // Create regex that matches the call (with optional whitespace variations)
+                const callRegex = new RegExp(escapedCallSignature.replace(/\s+/g, '\\s*'), 'g');
+                // Use safe function name with underscores instead of brackets
+                // e.g., fetcher[1] -> fetcher_1
+                const safeFunctionName = indexedVariableName.replace(/\[(\d+)\]/g, '_$1');
+                const mockFunctionName = `${importedExport.name}_${safeFunctionName}`;
+                fileContent = fileContent.replace(callRegex, `${mockFunctionName}()`);
+            }
+        }
+    }
+    else {
+        // Check if there's a single variable name that receives this function's return value
+        // Note: callVariableNames tracks the ACTUAL variable assignments (e.g., "const loadError = useLoaderData()")
+        // while calls can contain many entries including method chain accesses (e.g., "useLoaderData().config...")
+        // We only care about how many distinct variables receive the return value.
+        const singleCallVariableName = importedExport.callVariableNames &&
+            importedExport.callVariableNames.length === 1
+            ? importedExport.callVariableNames[0]
+            : undefined;
+        if (singleCallVariableName) {
+            // For single variable assignments, use the variable-qualified key for data lookup
+            // Use constructMockCode to generate proper dispatch functions for nested function calls
+            // (e.g., useTranslation returns { t } where t() needs to dispatch based on translation key)
+            const qualifiedKey = `${singleCallVariableName} <- ${importedExport.name}`;
+            // Keep the original function name since there's only one call - no need for unique names
+            mockCode = constructMockCode(qualifiedKey, dependencySchemas, importedExport.entityType, { keepOriginalFunctionName: true });
+            // If constructMockCode didn't generate code, fall back to simple return
+            if (!mockCode) {
+                mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${qualifiedKey}"];
+
+function ${importedExport.name}() {
+  return ${importedExport.name}ReturnValue;
+}`;
+            }
+        }
+        else {
+            // Check if any analysis (fileAnalyses or rootAnalysis) has this function's data
+            // under a variable-qualified key. The entity that CALLS the function (e.g., FileTableRow)
+            // has the dataForMocks with the variable-qualified key, not the root analysis (e.g., GitView).
+            let variableQualifiedKey;
+            // First check fileAnalyses (the analyses for the entity being written)
+            for (const analysis of fileAnalyses) {
+                const dataForMocks = analysis.metadata?.scenariosDataStructure?.dataForMocks;
+                if (dataForMocks) {
+                    variableQualifiedKey = Object.keys(dataForMocks).find((key) => {
+                        const match = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*<-\s*(.+)$/);
+                        return match && match[2] === importedExport.name;
+                    });
+                    if (variableQualifiedKey) {
+                        break;
+                    }
+                }
+            }
+            // If not found in fileAnalyses, fall back to rootAnalysis
+            if (!variableQualifiedKey) {
+                const dataForMocks = rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
+                if (dataForMocks) {
+                    variableQualifiedKey = Object.keys(dataForMocks).find((key) => {
+                        const match = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*<-\s*(.+)$/);
+                        return match && match[2] === importedExport.name;
+                    });
+                }
+            }
+            if (variableQualifiedKey) {
+                // Use the variable-qualified key found in the analysis
+                // Use constructMockCode to generate proper dispatch functions for nested function calls
+                // Keep the original function name since there's only one call - no need for unique names
+                mockCode = constructMockCode(variableQualifiedKey, dependencySchemas, importedExport.entityType, { keepOriginalFunctionName: true });
+                // If constructMockCode didn't generate code, fall back to simple return
+                if (!mockCode) {
+                    mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${variableQualifiedKey}"];
+
+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) {
@@ -89,7 +563,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`);
             }
@@ -101,13 +577,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
@@ -250,7 +762,7 @@ function captureArgumentsForTesting(args) {
         console.error('CodeYam Debug: Failed to capture arguments:', error);
     }
 }
-export default async function writeScenarioComponents({ project, file, entity, rootAnalysis, scenario, context, projectAnalyzer, framework, mocksDir, rootFile, namespaceMocks, writtenScenarioComponents = {}, fileStore, }) {
+export default async function writeScenarioComponents({ project, file, entity, rootAnalysis, scenario, context, projectAnalyzer, framework, mocksDir, rootFile, namespaceMocks, writtenScenarioComponents = {}, fileStore, exportAsNamed, }) {
     var _a;
     // Capture arguments for testing if debug mode is enabled
     captureArgumentsForTesting({
@@ -320,6 +832,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;
@@ -367,98 +920,243 @@ 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');
-            }
-        }
-        importedExportEntity.localFilePath = importedExport.filePath;
+        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;
+        }
         if (!importedExport.isMocked) {
-            const importedExportFilePath = importedExportEntity.localFilePath === file.path
-                ? (importedExport.resolvedFilePath ?? importedExport.filePath)
-                : importedExport.filePath;
-            if (importedExportFilePath !== file.path) {
+            // 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.
+            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)
                         : project.files.find((f) => f.path === importedExportFilePath);
+                    // Fallback: if file at resolvedFilePath doesn't exist, try filePath
+                    // This handles cases where the actual entity file isn't in project.files
+                    // (e.g., type re-exports where only the index file is tracked)
+                    if (!fileNotMocked &&
+                        importedExport.resolvedFilePath &&
+                        importedExport.filePath !== importedExport.resolvedFilePath) {
+                        const fallbackPath = importedExport.filePath;
+                        fileNotMocked = fileStore
+                            ? fileStore.getByPath(fallbackPath)
+                            : project.files.find((f) => f.path === fallbackPath);
+                    }
+                    // Skip if file still not found - can't write scenario component without the file
+                    if (!fileNotMocked) {
+                        continue;
+                    }
                     // Ensure content is loaded for the file
                     if (fileNotMocked &&
                         fileStore &&
-                        !fileStore.isContentLoaded(importedExportFilePath)) {
-                        fileNotMocked = await fileStore.ensureContent(importedExportFilePath);
+                        !fileStore.isContentLoaded(fileNotMocked.path)) {
+                        fileNotMocked = await fileStore.ensureContent(fileNotMocked.path);
+                    }
+                    // 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;
+                        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);
                     }
-                    const { scenarioComponentPaths: newScenarioComponentPaths, writtenScenarioComponents: updatedWrittenScenarioComponents, } = await writeScenarioComponents({
-                        project,
-                        file: fileNotMocked,
-                        entity: importedExportEntity,
-                        rootAnalysis,
-                        scenario,
-                        context,
-                        projectAnalyzer,
-                        framework,
-                        mocksDir,
-                        rootFile,
-                        namespaceMocks,
-                        writtenScenarioComponents,
-                        fileStore,
-                    });
-                    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 (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).
+                    const functionName = importedExport.name;
+                    // Add scenarios import if not present
+                    if (fileContent.indexOf('import { scenarios } from') === -1) {
+                        const mockDataPath = `${relativeMocksDir}/MockData_${safeFileName(scenario.name)}`;
+                        const importStatement = `import { scenarios } from "${mockDataPath}";`;
+                        fileContent = `${fileContent}\n\n\n${importStatement}`;
+                    }
+                    // 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}`;
+                    }
+                }
             }
         }
         // Try to find the import mapping using different key formats
         // The import mapping may use either absolute or relative paths as keys
-        // IMPORTANT: Use filePath (where it's imported FROM), not resolvedFilePath (where entity lives)
-        // For re-exports like ~codeyam/types, filePath="packages/types/index.ts",
-        // resolvedFilePath="packages/types/src/types/Commit.ts"
-        // We need to generate files at the import location (index.ts), not the entity location
+        // Use filePath (import source) for looking up the import mapping
+        // 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.
+        // 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 = [
@@ -501,18 +1199,49 @@ export default async function writeScenarioComponents({ project, file, entity, r
         else {
             // For non-mocked imports, rewrite the import path to point to the generated scenario file
             // Use fileStore for O(1) lookup when available
-            const fileNotMocked = fileStore
-                ? fileStore.getByPath(mockFilePathRelative)
-                : project.files.find((f) => f.path === mockFilePathRelative);
-            const fileName = mockFilePathRelative.split('/').pop();
+            // First try resolvedFilePath (where entity lives), fallback to filePath (import source)
+            let fileNotMocked = fileStore
+                ? fileStore.getByPath(scenarioFilePathRelative)
+                : project.files.find((f) => f.path === scenarioFilePathRelative);
+            // Track which path we're actually using for the scenario component
+            let actualScenarioFilePathRelative = scenarioFilePathRelative;
+            if (!fileNotMocked &&
+                importedExport.resolvedFilePath &&
+                importedExport.filePath !== importedExport.resolvedFilePath) {
+                // Fallback to filePath if file at resolvedFilePath doesn't exist
+                actualScenarioFilePathRelative = importedExport.filePath;
+                fileNotMocked = fileStore
+                    ? fileStore.getByPath(actualScenarioFilePathRelative)
+                    : project.files.find((f) => f.path === actualScenarioFilePathRelative);
+            }
+            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,
                     rootFile,
                     entity: importedExportEntity,
                     rootAnalysis,
-                    scenarioComponentPath: mockFilePathRelative,
+                    scenarioComponentPath: actualScenarioFilePathRelative,
                     project,
                     framework,
                     scenario,
@@ -520,13 +1249,84 @@ export default async function writeScenarioComponents({ project, file, entity, r
                     .split('.')
                     .slice(0, -1)
                     .join('.')
-                : mockFilePathRelative.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');
-                fileContent = fileContent.replace(importRegExp, `${path}$1`);
+                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)) {
+                    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;
+                    // 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
+                    // IMPORTANT: Only remove from import statements, NOT from the entire file!
+                    // The global patterns used previously would also match type annotations like:
+                    //   "param: MyType," in function signatures, corrupting the syntax.
+                    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');
+                    }
+                    // Match import statements that contain this entity and remove just the entity
+                    // Pattern: import { ... EntityName, ... } from '...'
+                    // We match the full import and use a replacer function to remove the entity name
+                    const importWithEntityPattern = new RegExp(`(import\\s*\\{)([^}]*\\b${escapedEntityName}\\b[^}]*)(\\}\\s*from\\s*['"][^'"]*['"];?)`, 'gm');
+                    fileContent = fileContent.replace(importWithEntityPattern, (match, prefix, namedImports, suffix) => {
+                        // Remove the entity name from the named imports
+                        let cleaned = namedImports
+                            .replace(new RegExp(`\\b${escapedEntityName}\\s*,\\s*`), '') // "EntityName, "
+                            .replace(new RegExp(`\\s*,\\s*${escapedEntityName}\\b`), '') // ", EntityName"
+                            .replace(new RegExp(`\\b${escapedEntityName}\\b`), ''); // "EntityName" (only one)
+                        // Clean up any double commas or leading/trailing commas
+                        cleaned = cleaned
+                            .replace(/,\s*,/g, ',')
+                            .replace(/^\s*,\s*/, '')
+                            .replace(/\s*,\s*$/, '');
+                        // If no imports left, remove the entire import statement
+                        if (cleaned.trim() === '') {
+                            return '';
+                        }
+                        return prefix + cleaned + suffix;
+                    });
+                    // 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
+                    //
+                    // IMPORTANT: We cannot use indexOf('// Scenario:') + '\n\n' here because:
+                    // 1. The header doesn't exist during processing
+                    // 2. indexOf would return -1, and indexOf('\n\n', -1) starts from 0
+                    // 3. This could find a \n\n inside a function body, inserting the import there!
+                    fileContent = newImport + '\n' + fileContent;
+                }
             }
         }
     }
@@ -535,6 +1335,24 @@ export default async function writeScenarioComponents({ project, file, entity, r
             continue;
         fileContent = addMockToContent(fileContent, nodeModuleImport, fileAnalyses, rootAnalysis, relativeMocksDir, scenario.name, importMapping[nodeModuleImport.filePath] ?? nodeModuleImport.filePath);
     }
+    // Rewrite node_module imports that have universal mocks
+    // Universal mocks create mock files at __codeyamMocks__/{safeFileName}.tsx
+    // We need to rewrite imports like `import { logger } from "@formbricks/logger"`
+    // to `import { logger } from "../__codeyamMocks__/_formbricks_logger.js"`
+    const universalMocks = project.metadata?.universalMocks ?? [];
+    const nodeModuleUniversalMocks = universalMocks.filter((mock) => mock.nodeModule && mock.content);
+    for (const universalMock of nodeModuleUniversalMocks) {
+        const originalPath = universalMock.filePath;
+        // Create the mock file name using the same safeFileName function as writeUniversalMocks
+        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"
+        // Pattern 3: import * as x from "module"
+        const importRegex = new RegExp(`(import\\s+(?:\\{[^}]*\\}|\\*\\s+as\\s+\\w+|\\w+)\\s+from\\s+)['"]${originalPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`, 'g');
+        fileContent = fileContent.replace(importRegex, `$1'${mockFileRelativePath}'`);
+    }
     if (rootAnalysis.entitySha === entity.sha &&
         entity.metadata?.notExported &&
         entity.name !== 'default') {
@@ -544,6 +1362,16 @@ export default async function writeScenarioComponents({ project, file, entity, r
             fileContent = `${fileContent}\n\n${exportStatement}`;
         }
     }
+    // When a default export is imported as named via re-export (e.g., index.tsx re-exports
+    // a default export as named), we need to add a named export so the parent's
+    // import statement works: `import { Name } from "./path.js"`
+    // The local variable name is the same as exportAsNamed (e.g., ScenarioEditor)
+    if (exportAsNamed) {
+        const namedExport = `export { ${exportAsNamed} };`;
+        if (!fileContent.includes(namedExport)) {
+            fileContent = `${fileContent}\n\n${namedExport}`;
+        }
+    }
     const basePath = safeFolder(file.path.split('/').slice(0, -1).join('/'));
     const extension = file.name.split('.').pop();
     // Include scenario name in path to allow multiple scenarios to coexist
@@ -560,10 +1388,234 @@ export default async function writeScenarioComponents({ project, file, entity, r
             scenario,
         });
     }
+    // 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
+    fileContent = stripHtmlBodyTags(fileContent, file.path, framework);
+    // Strip "server-only" imports for Next.js
+    // These cause errors when the scenario component is rendered client-side
+    fileContent = stripServerOnlyImport(fileContent);
+    fileContent = applyServerOnlyMocks(fileContent);
     // 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
     fileContent = rewriteAssetImports(fileContent, `${PROJECT_RELATIVE_PATH}/${file.path}`, scenarioComponentPath);
-    console.log('Writing scenario component', file.path, entity.name, scenarioComponentPath, fileContent.length);
+    // 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
+    fileContent = rewriteRelativeModuleImports(fileContent, `${PROJECT_RELATIVE_PATH}/${file.path}`, scenarioComponentPath);
+    /**
+     * 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()) {
+        const importPaths = extractInternalImportPaths(content);
+        let modifiedContent = content;
+        for (const importPath of importPaths) {
+            const resolvedPath = resolveImportPath(importPath, sourceFilePath, project);
+            if (!resolvedPath)
+                continue;
+            let importFile = fileStore
+                ? fileStore.getByPath(resolvedPath)
+                : project.files?.find((f) => f.path === resolvedPath);
+            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);
+                    transitiveContent = await processTransitiveImportsRecursively(transitiveContent, importFile.path, transitiveFilePath, visitedPaths);
+                    await writeFile(transitiveFilePath, transitiveContent);
+                    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)
+            const relativePath = getRelativePath(targetFilePath, transitiveFilePath);
+            const relativePathWithoutExt = relativePath.replace(/\.(ts|tsx|js|jsx)$/, '');
+            const safeRelativePath = safeFolder(relativePathWithoutExt);
+            const escapedImportPath = importPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const importRegex = new RegExp(`(from\\s*["'])${escapedImportPath}(["'])`, 'g');
+            modifiedContent = modifiedContent.replace(importRegex, `$1${safeRelativePath}$2`);
+        }
+        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"
+    const remainingImportPaths = extractInternalImportPaths(fileContent);
+    // 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));
+    for (const importPath of remainingImportPaths) {
+        // 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);
+            for (const nestedImportPath of nestedImportPaths) {
+                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);
+                    nestedContent = await processTransitiveImportsRecursively(nestedContent, nestedFile.path, nestedTransformedPath);
+                    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 })))}
@@ -574,15 +1626,21 @@ 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}`);
+    // 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}`;
+    }
+    await writeFile(scenarioComponentPath, finalContent);
     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),
-    });
     return { scenarioComponentPaths, writtenScenarioComponents };
 }
 //# sourceMappingURL=writeScenarioComponents.js.map