@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.15d0f46

package/analyzer-template/project/writeScenarioComponents.ts

@@ -1,6 +1,7 @@
 import {
   Analysis,
   Entity,
+  EntityType,
   File,
   Scenario,
   Project,
@@ -20,10 +21,261 @@ import {
 import { getRelativePath, safeFolder } from '~codeyam/generate';
 import constructMockCode from './constructMockCode';
 import { splitOutsideParenthesesAndArrays } from '~codeyam/ai';
-import { loadEntities } from '~codeyam/supabase';
 import * as fs from 'fs';
 import * as path from 'path';
+import ts from 'typescript';
 import { LazyFileStore } from './LazyFileStore';
+import { applyServerOnlyMocks } from './serverOnlyModules';
+
+// Debug timing helper for tracking where time is spent
+const DEBUG_TIMING = process.env.DEBUG_WRITE_SCENARIO === 'true';
+let debugStartTime: number;
+let debugLastTime: number;
+
+// Timeout protection to prevent infinite hangs
+const WRITE_SCENARIO_TIMEOUT_MS = parseInt(
+  process.env.WRITE_SCENARIO_TIMEOUT_MS || '300000', // Default 5 minutes
+  10,
+);
+
+class WriteScenarioTimeoutError extends Error {
+  constructor(operation: string, timeoutMs: number) {
+    super(
+      `WriteScenarioComponents timed out after ${timeoutMs}ms during: ${operation}`,
+    );
+    this.name = 'WriteScenarioTimeoutError';
+  }
+}
+
+async function withTimeout<T>(
+  operation: string,
+  promise: Promise<T>,
+  timeoutMs: number = WRITE_SCENARIO_TIMEOUT_MS,
+): Promise<T> {
+  let timeoutId: NodeJS.Timeout | undefined;
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new WriteScenarioTimeoutError(operation, timeoutMs));
+    }, timeoutMs);
+  });
+
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+function debugLog(message: string, extra?: Record<string, unknown>): void {
+  if (!DEBUG_TIMING) return;
+  const now = Date.now();
+  if (!debugStartTime) {
+    debugStartTime = now;
+    debugLastTime = now;
+  }
+  const elapsed = now - debugStartTime;
+  const delta = now - debugLastTime;
+  debugLastTime = now;
+  console.log(
+    `[WriteScenario +${elapsed}ms Δ${delta}ms] ${message}`,
+    extra ? JSON.stringify(extra, null, 2) : '',
+  );
+}
+
+function resetDebugTiming(): void {
+  debugStartTime = 0;
+  debugLastTime = 0;
+}
+
+/**
+ * Find the end position of the last import/export-from statement using TypeScript AST.
+ * This is more reliable than regex for handling multiline imports, comments, etc.
+ *
+ * @param content - The file content to analyze
+ * @returns The position after the last import statement, or 0 if no imports found
+ */
+function findEndOfImports(content: string): number {
+  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: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Remove a named import from file content using TypeScript AST.
+ * Handles both regular imports (`EntityName`) and type-only imports (`type EntityName`).
+ *
+ * @param fileContent - The file content to modify
+ * @param entityName - The name of the entity to remove from imports
+ * @returns The modified file content with the entity removed from imports
+ */
+function removeNamedImportAst(fileContent: string, entityName: string): string {
+  try {
+    const sourceFile = ts.createSourceFile(
+      'temp.tsx',
+      fileContent,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TSX,
+    );
+
+    const replacements: { start: number; end: number; replacement: string }[] =
+      [];
+
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement)) continue;
+      if (!statement.importClause?.namedBindings) continue;
+      if (!ts.isNamedImports(statement.importClause.namedBindings)) continue;
+
+      const namedImports = statement.importClause.namedBindings;
+      const elements = namedImports.elements;
+
+      // Find the element that matches our entity name
+      const matchingIndex = elements.findIndex(
+        (el) => el.name.text === entityName,
+      );
+      if (matchingIndex === -1) continue;
+
+      // Check if there's a default import (e.g., `import DefaultName, { NamedImport } from '...'`)
+      const hasDefaultImport = !!statement.importClause.name;
+
+      // If this is the only named import AND there's no default import, remove the entire statement
+      if (elements.length === 1 && !hasDefaultImport) {
+        // Find the end including any trailing newline
+        let end = statement.getEnd();
+        const afterStatement = fileContent.slice(end);
+        const trailingNewline = afterStatement.match(/^\r?\n/);
+        if (trailingNewline) {
+          end += trailingNewline[0].length;
+        }
+        replacements.push({
+          start: statement.getStart(sourceFile),
+          end,
+          replacement: '',
+        });
+        continue;
+      }
+
+      // Otherwise, rebuild the import without this element
+      const remainingElements = elements.filter((_, i) => i !== matchingIndex);
+
+      // Get the module specifier
+      const moduleSpecifier = statement.moduleSpecifier;
+      if (!ts.isStringLiteral(moduleSpecifier)) continue;
+
+      // Preserve import type modifier if present
+      const importTypePrefix = statement.importClause.isTypeOnly ? 'type ' : '';
+
+      // Get the default import name if present
+      const defaultImportName = statement.importClause.name?.text;
+
+      let newImport: string;
+
+      if (remainingElements.length === 0) {
+        // All named imports were removed, but there's a default import to preserve
+        // (we only get here when hasDefaultImport is true, because otherwise we'd have
+        // removed the whole statement at the elements.length === 1 check above)
+        newImport = `import ${defaultImportName} from ${moduleSpecifier.getText(sourceFile)};`;
+      } else {
+        // Build the new named imports string
+        const newNamedImports = remainingElements
+          .map((el) => {
+            const isTypeOnly = el.isTypeOnly;
+            const name = el.name.text;
+            const propertyName = el.propertyName?.text;
+            if (propertyName) {
+              return isTypeOnly
+                ? `type ${propertyName} as ${name}`
+                : `${propertyName} as ${name}`;
+            }
+            return isTypeOnly ? `type ${name}` : name;
+          })
+          .join(', ');
+
+        // Build the new import statement, preserving default import if present
+        const defaultImportPrefix = defaultImportName
+          ? `${defaultImportName}, `
+          : '';
+        newImport = `import ${importTypePrefix}${defaultImportPrefix}{ ${newNamedImports} } from ${moduleSpecifier.getText(sourceFile)};`;
+      }
+
+      replacements.push({
+        start: statement.getStart(sourceFile),
+        end: statement.getEnd(),
+        replacement: newImport,
+      });
+    }
+
+    // Apply replacements in reverse order to preserve positions
+    let result = fileContent;
+    replacements.sort((a, b) => b.start - a.start);
+    for (const { start, end, replacement } of replacements) {
+      result = result.slice(0, start) + replacement + result.slice(end);
+    }
+
+    return result;
+  } catch (error) {
+    console.warn('[removeNamedImportAst] Failed to parse file:', error);
+    return fileContent; // Return original content on error
+  }
+}
+
+/**
+ * Map nested dist paths to src paths.
+ * Some build tools create nested structures like:
+ *   packages/X/dist/X/src/Y.d.ts
+ * when the source is at:
+ *   packages/X/src/Y.ts
+ * This function normalizes such paths to the src location.
+ */
+function mapNestedDistToSrc(filePath: string): string {
+  // 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;
+}
 
 interface WriteScenarioComponentsArgs {
   project: Project;
@@ -43,14 +295,23 @@ interface WriteScenarioComponentsArgs {
   })[];
   writtenScenarioComponents?: { [key: string]: string[] };
   fileStore?: LazyFileStore;
+  /**
+   * When a default export needs to be accessible as a named export (e.g., when
+   * the parent imports it as `{ Name }` via an index re-export), pass the name here.
+   * A re-export statement `export { default as Name };` will be added to the output.
+   */
+  exportAsNamed?: string;
 }
 
 type EnhancedImportedExport = Omit<
   Entity['metadata']['importedExports'][0],
-  'entityType' | 'calls'
+  'calls' | 'entityType' | 'callVariableNames'
 > & {
   analysisId: string;
   isNodeModule?: boolean;
+  entityType?: EntityType; // Optional because nodeModuleImports don't have it
+  calls?: readonly string[]; // Optional - used for Zod schema detection heuristic
+  callVariableNames?: readonly string[]; // Variable names receiving the return value of each call
 };
 
 function hasMockStructure(
@@ -73,6 +334,7 @@ function hasMockStructure(
           importedExport.filePath
         ]?.[importedExport.name],
     )?.metadata?.mergedDataStructure?.dependencySchemas,
+    importedExport.entityType,
   );
 }
 
@@ -83,56 +345,499 @@ function isIndexPath(filePath: string) {
 }
 
 /**
- * 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.
+ *
+ * @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: string, entityName: string): string {
+  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.
  *
- * Handles patterns like:
+ * 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"
- * - import logo from "./logo.png"
+ * - localFont({ src: "../fonts/font.woff2" })
+ * - Image src="../images/logo.png"
+ * - Any other string literal with a relative asset path
  */
 function rewriteAssetImports(
   fileContent: string,
   originalFilePath: string,
   newFilePath: string,
 ): string {
-  // 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`,
+
+  // 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(
+    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 pathParts = assetPath.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 asset
+      const absoluteAssetPath = resolvedParts.join('/');
+
+      // Calculate the new relative path from new file location
+      const newRelativePath = getRelativePath(newFilePath, absoluteAssetPath);
+
+      // 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: string,
+  originalFilePath: string,
+  newFilePath: string,
+): string {
+  // 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"
+  // - import foo from "../path"
+  // - import * as foo from "./path"
+  // - 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(assetImportRegex, (match, quote, importPath) => {
-    // 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 resolvedParts = [...originalDirParts];
+  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;
+      }
 
-    for (const part of importParts) {
+      // 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: string,
+  filePath: string,
+  framework: ProjectFramework,
+): string {
+  // 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: string): string {
+  // 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: string): string[] {
+  // Always use AST parsing - regex with nested quantifiers can cause catastrophic
+  // backtracking that hangs on a single .exec() call (before iteration limits kick in)
+  return extractInternalImportPathsAst(fileContent);
+}
+
+/**
+ * Extract internal import paths using TypeScript AST - more reliable for large files
+ */
+function extractInternalImportPathsAst(fileContent: string): string[] {
+  const importPaths: string[] = [];
+
+  try {
+    const sourceFile = ts.createSourceFile(
+      'temp.ts',
+      fileContent,
+      ts.ScriptTarget.Latest,
+      true,
+    );
+
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement) && statement.moduleSpecifier) {
+        const moduleSpecifier = statement.moduleSpecifier;
+        if (ts.isStringLiteral(moduleSpecifier)) {
+          const importPath = moduleSpecifier.text;
+          // Skip node_modules imports (bare specifiers)
+          if (
+            importPath.startsWith('.') ||
+            importPath.startsWith('@/') ||
+            importPath.startsWith('~/') ||
+            importPath.startsWith('#')
+          ) {
+            importPaths.push(importPath);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(
+      '[extractInternalImportPathsAst] Failed to parse file:',
+      error,
+    );
+  }
+
+  return importPaths;
+}
+
+/**
+ * Resolve an import path to a file path relative to the project.
+ * Handles path aliases like @/, ~/, and relative paths.
+ */
+function resolveImportPath(
+  importPath: string,
+  currentFilePath: string,
+  project: Project,
+): string | null {
+  let resolvedPath: string;
+  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: string[] = [];
+
+    for (const part of parts) {
       if (part === '..') {
-        resolvedParts.pop();
-      } else if (part !== '.') {
-        resolvedParts.push(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;
+  }
 
-    // Build the project-relative path to the asset
-    const absoluteAssetPath = resolvedParts.join('/');
+  // Try to find the file with various extensions
+  const extensions = ['', '.ts', '.tsx', '.js', '.jsx'];
 
-    // Calculate the new relative path from new file location
-    const newRelativePath = getRelativePath(newFilePath, absoluteAssetPath);
+  // 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;
+      }
+    }
 
-    // Reconstruct the import statement
-    return match.replace(importPath, newRelativePath);
-  });
+    // 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: string,
   importedExport: EnhancedImportedExport,
@@ -157,37 +862,171 @@ function addMockToContent(
       rootAnalysis.metadata?.mergedDataStructure?.dependencySchemas;
   }
 
-  const mockCode = constructMockCode(importedExport.name, dependencySchemas);
+  // 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: string | undefined;
+  const variableMockCodes: string[] = [];
+
+  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: Record<string, number> = {};
+
+    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 (!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,
-      ),
-    );
+      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: string | undefined;
+
+      // 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;
   }
 
@@ -204,8 +1043,13 @@ function addMockToContent(
       );
       fileContent = fileContent.replace(entireImportRegExp, '');
     } else {
+      // Escape regex special characters in importPath (e.g., brackets in [environmentId])
+      const escapedImportPath = importPath.replace(
+        /[.*+?^${}()|[\]\\]/g,
+        '\\$&',
+      );
       const importRegExp = new RegExp(
-        `(import(?:(?!${firstPart}|from|import)[\\s\\S])*?)${firstPart}(?:,\\s*)?((?:(?!import)[\\s\\S])*?from\\s+['"]${importPath}['"])`,
+        `(import(?:(?!${firstPart}|from|import)[\\s\\S])*?)${firstPart}(?:,\\s*)?((?:(?!import)[\\s\\S])*?from\\s+['"]${escapedImportPath}['"])`,
         'm',
       );
 
@@ -218,23 +1062,73 @@ function addMockToContent(
         fileContent = fileContent.replace(importRegExp, '$1$2');
       }
 
-      // Remove empty imports entirely to avoid partial commenting issues with multiline imports
-      // This handles both single-line and multiline empty imports
+      // Remove empty imports entirely to avoid partial commenting issues with multiline imports
+      // This handles both single-line and multiline empty imports
+      fileContent = fileContent.replace(
+        /import\s*\{\s*\}\s*from\s+['"][^'"]*['"];?\s*\n?/g,
+        '',
+      );
+    }
+  } 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(
-        /import\s*\{\s*\}\s*from\s+['"][^'"]*['"];?\s*\n?/g,
-        '',
+        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}";`;
   }
 
-  fileContent += `\n\n// Mock constructed using mocksDataStructure from analyses: ${fileAnalyses.map((a) => a.id).join(', ')}\n${mockCode}`;
+  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;
+  }
 
   return fileContent;
 }
@@ -409,10 +1303,20 @@ export default async function writeScenarioComponents({
   namespaceMocks,
   writtenScenarioComponents = {},
   fileStore,
+  exportAsNamed,
 }: WriteScenarioComponentsArgs): Promise<{
   scenarioComponentPaths: string[];
   writtenScenarioComponents: { [key: string]: string[] };
 }> {
+  // Reset debug timing for this invocation
+  resetDebugTiming();
+  debugLog('START writeScenarioComponents', {
+    filePath: file.path,
+    entityName: entity.name,
+    scenarioName: scenario.name,
+    isRootFile: !rootFile || rootFile === file,
+  });
+
   // Capture arguments for testing if debug mode is enabled
   captureArgumentsForTesting({
     project,
@@ -529,6 +1433,65 @@ export default async function writeScenarioComponents({
   );
 
   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: string | null = 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();
 
@@ -573,7 +1536,24 @@ export default async function writeScenarioComponents({
     return 0;
   });
 
+  debugLog('Starting main importedExports loop', {
+    count: sortedImportedExports.length,
+    fileContentLength: fileContent.length,
+  });
+
+  let importedExportIndex = 0;
   for (const importedExport of sortedImportedExports) {
+    importedExportIndex++;
+    if (importedExportIndex % 5 === 0 || importedExportIndex === 1) {
+      debugLog(
+        `Processing importedExport ${importedExportIndex}/${sortedImportedExports.length}`,
+        {
+          name: importedExport.name,
+          filePath: importedExport.filePath,
+          isMocked: importedExport.isMocked,
+        },
+      );
+    }
     // IMPORTANT: The import mapping keys may be either absolute or relative paths
     // depending on how they were created by the file analyzer. We try multiple formats.
     // Also need to normalize paths to handle /tmp vs /private/tmp on macOS
@@ -592,113 +1572,205 @@ export default async function writeScenarioComponents({
         )
       : undefined;
 
-    let importedExportEntity =
+    const 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',
-        );
+    // 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))}`,
+      );
     }
 
-    (importedExportEntity as Entity).localFilePath = importedExport.filePath;
+    if (importedExportEntity) {
+      (importedExportEntity as Entity).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)
+            !fileStore.isContentLoaded(fileNotMocked.path)
           ) {
-            fileNotMocked = await fileStore.ensureContent(
-              importedExportFilePath,
-            );
+            fileNotMocked = await fileStore.ensureContent(fileNotMocked.path);
           }
 
-          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);
+          // For type/data entities, create a transformed copy WITHOUT recursion.
+          // Data entities don't need mocking - they're just constants/types that need
+          // to be available. But we still need to:
+          // 1. Strip server-only imports (Next.js directive that breaks client components)
+          // 2. Write the transformed file so imports can be rewritten to point to it
+          if (
+            importedExportEntity.entityType === 'type' ||
+            importedExportEntity.entityType === 'data'
+          ) {
+            // For data entities, we write ONE transformed copy per source file, not per entity.
+            // Check if we've already written ANY entity from this file - if so, skip writing.
+            // Use a special marker '__data_file_written__' to track file-level writes.
+            // Also track which SHA was used via '__data_file_sha__:xxx' so subsequent
+            // entities from the same file can reuse it for import rewriting.
+            const dataFileWritten = writtenScenarioComponents[
+              importedExportFilePath
+            ]?.includes('__data_file_written__');
+
+            if (!dataFileWritten) {
+              // Construct the scenario file path for the data file
+              // Use a file-level identifier (first entity's sha) for consistency
+              const dataFileBasePath = safeFolder(
+                fileNotMocked.path.split('/').slice(0, -1).join('/'),
+              );
+              const dataFileExtension = fileNotMocked.name.split('.').pop();
+              const dataFileIsIndex = isIndexPath(fileNotMocked.path);
+              // Use 'data' prefix to distinguish from entity-specific files
+              const dataScenarioPath = `${PROJECT_RELATIVE_PATH}/${dataFileBasePath}/${importedExportEntity.sha}_${dataFileIsIndex ? 'index_' : ''}data_${safeFileName(scenario.name)}.${dataFileExtension}`;
+
+              // Get the file content and apply transformations
+              let dataFileContent = fileNotMocked.content ?? '';
+
+              // Strip server-only imports - these break when imported by client components
+              dataFileContent = stripServerOnlyImport(dataFileContent);
+              dataFileContent = applyServerOnlyMocks(dataFileContent);
+
+              // Write the transformed data entity file
+              await writeFile(dataScenarioPath, dataFileContent);
+              scenarioComponentPaths.push(dataScenarioPath);
+
+              // Mark file as written so we don't duplicate for other entities from same file
+              if (!writtenScenarioComponents[importedExportFilePath]) {
+                writtenScenarioComponents[importedExportFilePath] = [];
+              }
+              writtenScenarioComponents[importedExportFilePath].push(
+                '__data_file_written__',
+              );
+              // Also store the SHA used for this data file so subsequent entities can use it
+              writtenScenarioComponents[importedExportFilePath].push(
+                `__data_file_sha__:${importedExportEntity.sha}`,
+              );
+            }
+
+            // Mark this specific entity as written (for the entity-level check)
+            if (!writtenScenarioComponents[importedExportFilePath]) {
+              writtenScenarioComponents[importedExportFilePath] = [];
+            }
+            writtenScenarioComponents[importedExportFilePath].push(
+              importedExport.name,
+            );
+
+            // Don't recurse - data entities don't need their dependencies processed
+            // The import rewriting will happen later in this same loop iteration
+            // (at lines ~1590-1702) to point imports to this transformed file
+          } else {
+            // For visual/library entities, recurse to process their dependencies
+
+            // When a default export is imported as named (via index re-export), we need
+            // to add a named re-export to the scenario component so the import works.
+            // e.g., if file has `export default X` but parent does `import { X } from '...'`
+            const needsNamedReExport =
+              importedExport.resolvedIsDefault === true &&
+              importedExport.isDefault === false;
+
+            debugLog(
+              `Recursing into writeScenarioComponents for ${importedExportEntity.name}`,
+              {
+                entityName: importedExportEntity.name,
+                filePath: fileNotMocked.path,
+              },
+            );
+            const {
+              scenarioComponentPaths: newScenarioComponentPaths,
+              writtenScenarioComponents: updatedWrittenScenarioComponents,
+            } = await withTimeout(
+              `recursive writeScenarioComponents for ${importedExportEntity.name}`,
+              writeScenarioComponents({
+                project,
+                file: fileNotMocked,
+                entity: importedExportEntity,
+                rootAnalysis,
+                scenario,
+                context,
+                projectAnalyzer,
+                framework,
+                mocksDir,
+                rootFile,
+                namespaceMocks,
+                writtenScenarioComponents,
+                fileStore,
+                // Pass the import name so we can add `export { default as Name };`
+                exportAsNamed: needsNamedReExport
+                  ? importedExport.name
+                  : undefined,
+              }),
+              60000, // 1 minute timeout for recursive calls
+            );
+            debugLog(
+              `Completed recursive writeScenarioComponents for ${importedExportEntity.name}`,
+            );
+            writtenScenarioComponents = updatedWrittenScenarioComponents;
+            scenarioComponentPaths.push(...newScenarioComponentPaths);
+          }
         }
       }
     } else if (
@@ -706,21 +1778,58 @@ export default async function writeScenarioComponents({
       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: string) =>
+          /\.(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,
@@ -729,18 +1838,69 @@ export default async function writeScenarioComponents({
             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 = [
@@ -794,11 +1954,54 @@ export default async function writeScenarioComponents({
     } 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,
@@ -810,7 +2013,7 @@ export default async function writeScenarioComponents({
             rootFile,
             entity: importedExportEntity,
             rootAnalysis,
-            scenarioComponentPath: mockFilePathRelative,
+            scenarioComponentPath: actualScenarioFilePathRelative,
             project,
             framework,
             scenario,
@@ -818,9 +2021,9 @@ export default async function writeScenarioComponents({
             .split('.')
             .slice(0, -1)
             .join('.')
-        : mockFilePathRelative.replace(
+        : actualScenarioFilePathRelative.replace(
             `${fileName}`,
-            `${importedExportEntity.sha}_${fileNotMockedIsIndex ? 'index_' : ''}${safeFileName(importedExportEntity.name)}_${safeFileName(scenario.name)}`,
+            `${entityShaForPath}_${fileNotMockedIsIndex ? 'index_' : ''}${scenarioFileName}_${safeFileName(scenario.name)}`,
           );
 
       const path = safeFolder(getRelativePath(filePath, mockFilePath));
@@ -829,11 +2032,75 @@ export default async function writeScenarioComponents({
       // 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')}(['"])`,
+          `${escapeRegExp(mockImportMapping)}(['"])`,
           'g',
         );
 
-        fileContent = fileContent.replace(importRegExp, `${path}$1`);
+        // 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
+          // Use AST-based removal to properly handle type-only imports like `type EntityName`
+          const escapedEntityName = escapeRegExp(entityImportName);
+
+          // For default imports: remove "DefaultName, " from "import DefaultName, { ... }"
+          // This handles the case where a default export is being split out
+          if (importedExport.isDefault) {
+            const defaultImportPattern = new RegExp(
+              `(import\\s+)${escapedEntityName}\\s*,\\s*(\\{)`,
+              'gm',
+            );
+            fileContent = fileContent.replace(defaultImportPattern, '$1$2');
+          }
+
+          // Remove the named import using AST parsing
+          // This properly handles:
+          // - Regular imports: `import { EntityName } from '...'`
+          // - Type-only imports: `import { type EntityName } from '...'`
+          // - Mixed imports: `import { type EntityName, OtherName } from '...'`
+          fileContent = removeNamedImportAst(fileContent, entityImportName);
+
+          // Add the new import at the beginning of fileContent
+          // Note: The header comment (// Scenario:) doesn't exist yet - it's prepended at writeFile time
+          // So prepending here puts the import right after the header in the final output
+          //
+          // 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;
+        }
       }
     }
   }
@@ -852,6 +2119,36 @@ export default async function writeScenarioComponents({
     );
   }
 
+  // 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"`
+  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 &&
@@ -864,6 +2161,17 @@ export default async function writeScenarioComponents({
     }
   }
 
+  // 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'`
+  // 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
@@ -882,21 +2190,503 @@ export default async function writeScenarioComponents({
     });
   }
 
+  debugLog('Route path computed', { scenarioComponentPath });
+
+  // Strip <html> and <body> tags from root layout files for Next.js
+  // These tags cause hydration errors when the scenario layout is nested under the real root
+  debugLog('Starting stripHtmlBodyTags');
+  fileContent = stripHtmlBodyTags(fileContent, file.path, framework);
+  debugLog('Completed stripHtmlBodyTags');
+
+  // Strip "server-only" imports for Next.js
+  // These cause errors when the scenario component is rendered client-side
+  debugLog('Starting stripServerOnlyImport');
+  fileContent = stripServerOnlyImport(fileContent);
+  debugLog('Starting applyServerOnlyMocks');
+  fileContent = applyServerOnlyMocks(fileContent);
+  debugLog('Completed server-only processing');
+
   // Rewrite asset imports (CSS, images, fonts, etc.) to correct relative paths
   // The original file path is relative to PROJECT_RELATIVE_PATH, the new path is scenarioComponentPath
+  debugLog('Starting rewriteAssetImports');
   fileContent = rewriteAssetImports(
     fileContent,
     `${PROJECT_RELATIVE_PATH}/${file.path}`,
     scenarioComponentPath,
   );
+  debugLog('Completed rewriteAssetImports');
 
-  console.log(
-    'Writing scenario component',
-    file.path,
-    entity.name,
+  // Rewrite relative TypeScript/JavaScript module imports to correct relative paths
+  // This handles cases where the file is moved (e.g., from [environmentId]/ to _environmentId_/)
+  // and relative imports like "./lib/organization" need to be rewritten
+  debugLog('Starting rewriteRelativeModuleImports');
+  fileContent = rewriteRelativeModuleImports(
+    fileContent,
+    `${PROJECT_RELATIVE_PATH}/${file.path}`,
     scenarioComponentPath,
-    fileContent.length,
   );
+  debugLog('Completed rewriteRelativeModuleImports');
+
+  /**
+   * Recursively process a file's imports to create transitive copies with server-only stripped.
+   * This handles chains of arbitrary depth: A -> B -> C -> D where each needs server-only removed.
+   * Uses a visited set to detect and break circular import chains.
+   *
+   * @param content - The file content to process
+   * @param sourceFilePath - The original source file path (for resolving relative imports)
+   * @param targetFilePath - The path where this content will be written (for computing relative imports)
+   * @param visitedPaths - Set of file paths currently being processed (for cycle detection)
+   * @returns The modified content with imports rewritten to point to transitive copies
+   */
+  async function processTransitiveImportsRecursively(
+    content: string,
+    sourceFilePath: string,
+    targetFilePath: string,
+    visitedPaths: Set<string> = new Set(),
+    depth: number = 0,
+    startTime: number = Date.now(),
+  ): Promise<string> {
+    // Global timeout for entire transitive processing
+    const GLOBAL_TIMEOUT_MS = 60000; // 1 minute max for all transitive processing
+    const elapsed = Date.now() - startTime;
+    if (elapsed > GLOBAL_TIMEOUT_MS) {
+      throw new Error(
+        `processTransitiveImportsRecursively exceeded ${GLOBAL_TIMEOUT_MS}ms (elapsed: ${elapsed}ms) at depth=${depth} for ${sourceFilePath}`,
+      );
+    }
+
+    const importPaths = extractInternalImportPaths(content);
+    debugLog(`processTransitiveImportsRecursively depth=${depth}`, {
+      sourceFilePath,
+      importCount: importPaths.length,
+      visitedCount: visitedPaths.size,
+    });
+    let modifiedContent = content;
+
+    // Safety check: limit iterations to prevent infinite loops
+    const MAX_IMPORTS_PER_FILE = 100;
+    if (importPaths.length > MAX_IMPORTS_PER_FILE) {
+      console.warn(
+        `[WriteScenario] WARNING: File ${sourceFilePath} has ${importPaths.length} imports (> ${MAX_IMPORTS_PER_FILE}), limiting processing`,
+      );
+    }
+
+    let importIndex = 0;
+    debugLog(
+      `Starting import loop at depth=${depth}, ${importPaths.length} imports to process`,
+    );
+    const slicedImports = importPaths.slice(0, MAX_IMPORTS_PER_FILE);
+    for (const importPath of slicedImports) {
+      if (!importPath) {
+        continue;
+      }
+      importIndex++;
+      debugLog(
+        `[LOOP] depth=${depth} import ${importIndex}/${Math.min(importPaths.length, MAX_IMPORTS_PER_FILE)}: ${importPath}`,
+      );
+      debugLog(`[LOOP] Calling resolveImportPath...`);
+      const resolvedPath = resolveImportPath(
+        importPath,
+        sourceFilePath,
+        project,
+      );
+      debugLog(
+        `[LOOP] resolveImportPath returned: ${resolvedPath?.slice(0, 80) ?? 'null'}`,
+      );
+      if (!resolvedPath) continue;
+
+      debugLog(`[LOOP] Looking up importFile...`);
+      let importFile = fileStore
+        ? fileStore.getByPath(resolvedPath)
+        : project.files?.find((f) => f.path === resolvedPath);
+      debugLog(
+        `[LOOP] importFile lookup result: ${importFile ? 'found' : 'not found'}`,
+      );
+      if (!importFile) continue;
+
+      // Build the transitive file path (needed for import rewriting even if we skip creating)
+      const basePath = safeFolder(
+        importFile.path.split('/').slice(0, -1).join('/'),
+      );
+      const extension = importFile.name.split('.').pop();
+      const isIndex = isIndexPath(importFile.path);
+      const pathHash = safeFileName(importFile.path);
+      const transitiveFilePath = `${PROJECT_RELATIVE_PATH}/${basePath}/${pathHash}_${isIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${extension}`;
+
+      // Check if this is a circular import (we're already processing this file)
+      const isCircularImport = visitedPaths.has(resolvedPath);
+
+      // Check if already processed
+      const alreadyProcessed = writtenScenarioComponents[
+        resolvedPath
+      ]?.includes('__transitive_file_written__');
+
+      // Only create the transitive file if not circular and not already processed
+      if (!isCircularImport && !alreadyProcessed) {
+        // Load content if needed
+        if (!importFile.content && fileStore) {
+          importFile = await fileStore.ensureContent(resolvedPath);
+        }
+        if (!importFile?.content) {
+          // Can't create transitive, but still try to rewrite import below
+        } else {
+          // Mark as being processed BEFORE recursing (to detect cycles)
+          visitedPaths.add(resolvedPath);
+
+          // Strip server-only and mock server-only packages, then recursively process imports
+          let transitiveContent = stripServerOnlyImport(importFile.content);
+          transitiveContent = applyServerOnlyMocks(transitiveContent);
+          debugLog(
+            `processTransitiveImportsRecursively depth=${depth} for ${importFile.path}`,
+          );
+          debugLog(
+            `Calling processTransitiveImportsRecursively depth=${depth + 1} for ${importFile.path}`,
+          );
+          transitiveContent = await withTimeout(
+            `processTransitiveImportsRecursively depth=${depth} for ${path.basename(importFile.path)}`,
+            processTransitiveImportsRecursively(
+              transitiveContent,
+              importFile.path,
+              transitiveFilePath,
+              visitedPaths,
+              depth + 1,
+              startTime, // Pass through the original start time
+            ),
+            30000, // 30 second timeout per transitive import
+          );
+          debugLog(
+            `withTimeout returned for depth=${depth}, transitiveContent length=${transitiveContent.length}`,
+          );
+          debugLog(
+            `Completed processTransitiveImportsRecursively depth=${depth} for ${importFile.path}`,
+          );
+
+          debugLog(`Writing transitive file depth=${depth}`, {
+            transitiveFilePath: path.basename(transitiveFilePath),
+            contentLength: transitiveContent.length,
+          });
+          await writeFile(transitiveFilePath, transitiveContent);
+          debugLog(`Wrote transitive file depth=${depth}`);
+          scenarioComponentPaths.push(transitiveFilePath);
+
+          if (!writtenScenarioComponents[resolvedPath]) {
+            writtenScenarioComponents[resolvedPath] = [];
+          }
+          writtenScenarioComponents[resolvedPath].push(
+            '__transitive_file_written__',
+          );
+        }
+      }
+
+      // ALWAYS rewrite the import to point to the transitive copy
+      // (even for circular imports or already-processed files)
+      debugLog(`Rewriting import path depth=${depth}`, {
+        importPath,
+        resolvedPath,
+      });
+      const relativePath = getRelativePath(targetFilePath, transitiveFilePath);
+      const relativePathWithoutExt = relativePath.replace(
+        /\.(ts|tsx|js|jsx)$/,
+        '',
+      );
+      const safeRelativePath = safeFolder(relativePathWithoutExt);
+      const escapedImportPath = importPath.replace(
+        /[.*+?^${}()|[\]\\]/g,
+        '\\$&',
+      );
+      debugLog(`Applying regex depth=${depth}`, {
+        escapedImportPath,
+        contentLength: modifiedContent.length,
+      });
+      // Quick check if the import path even exists in content
+      const simpleCheck = modifiedContent.includes(importPath);
+      debugLog(
+        `Simple check: importPath "${importPath}" exists: ${simpleCheck}`,
+      );
+      if (!simpleCheck) {
+        debugLog(`Skipping regex - import path not found in content`);
+      } else {
+        const regexPattern = `(from\\s*["'])${escapedImportPath}(["'])`;
+        debugLog(`Regex pattern: ${regexPattern.slice(0, 100)}`);
+        const importRegex = new RegExp(regexPattern, 'g');
+        debugLog(`About to call replace...`);
+
+        // Timing for regex replace to detect slow operations
+        const replaceStart = Date.now();
+        modifiedContent = modifiedContent.replace(
+          importRegex,
+          `$1${safeRelativePath}$2`,
+        );
+        const replaceTime = Date.now() - replaceStart;
+        if (replaceTime > 100) {
+          console.warn(
+            `[WriteScenario] SLOW regex replace: ${replaceTime}ms for pattern ${regexPattern.slice(0, 50)} on ${modifiedContent.length} bytes`,
+          );
+        }
+        debugLog(`Regex applied depth=${depth} in ${replaceTime}ms`);
+      }
+      debugLog(`[LOOP END] depth=${depth} import ${importIndex} completed`);
+    }
+
+    debugLog(`[LOOP DONE] Exiting import loop at depth=${depth}`);
+    debugLog(
+      `Returning from processTransitiveImportsRecursively depth=${depth}`,
+    );
+    return modifiedContent;
+  }
+
+  // Process remaining internal imports that weren't in importedExports
+  // This handles transitive dependencies: when the file content includes code (e.g., from
+  // other functions in the same file) that imports from files with "server-only"
+  debugLog('Extracting remaining import paths');
+  const remainingImportPaths = extractInternalImportPaths(fileContent);
+  debugLog('Found remaining import paths', {
+    count: remainingImportPaths.length,
+  });
+
+  // Get all file paths that are in importedExports - these are handled by main processing
+  const importedExportFilePaths = new Set(
+    allImportedExports.map((ie) => ie.resolvedFilePath || ie.filePath),
+  );
+
+  debugLog('Starting remaining imports loop', {
+    remainingCount: remainingImportPaths.length,
+    importedExportCount: importedExportFilePaths.size,
+  });
+
+  let remainingImportIndex = 0;
+  debugLog(
+    `[REMAINING] Starting remaining imports loop, ${remainingImportPaths.length} imports`,
+  );
+  for (const importPath of remainingImportPaths) {
+    remainingImportIndex++;
+    debugLog(
+      `[REMAINING LOOP] import ${remainingImportIndex}/${remainingImportPaths.length}: ${importPath}`,
+    );
+    // Resolve the import path to a project file path
+    const resolvedFilePath = resolveImportPath(importPath, file.path, project);
+
+    if (!resolvedFilePath) {
+      // Can't resolve - might be a path we don't handle, skip it
+      continue;
+    }
+
+    // Find the file in project.files, using fileStore for O(1) lookup when available
+    // We need to find the file BEFORE checking importedExports to see if it has server-only
+    let targetFile = fileStore
+      ? fileStore.getByPath(resolvedFilePath)
+      : project.files?.find((f) => f.path === resolvedFilePath);
+
+    // Skip if this import is in importedExports - it's handled by the main processing loop
+    // UNLESS the file contains "server-only", in which case we still need a transitive copy
+    // with server-only stripped (even if some exports from the file are mocked).
+    if (importedExportFilePaths.has(resolvedFilePath)) {
+      // Check if the file has server-only before skipping
+      let fileContent = targetFile?.content;
+      if (!fileContent && targetFile && fileStore) {
+        // Load content to check for server-only
+        const loadedFile = await fileStore.ensureContent(resolvedFilePath);
+        fileContent = loadedFile?.content;
+        if (loadedFile) {
+          targetFile = loadedFile;
+        }
+      }
+
+      const hasServerOnly =
+        fileContent && /import\s+["']server-only["']/.test(fileContent);
+
+      if (!hasServerOnly) {
+        continue;
+      }
+      // File has server-only - continue processing to create transitive copy
+    }
+    if (!targetFile) {
+      continue;
+    }
+
+    // Compute the transformed file path (needed for import rewriting even if already processed)
+    const targetFileBasePath = safeFolder(
+      targetFile.path.split('/').slice(0, -1).join('/'),
+    );
+    const targetFileExtension = targetFile.name.split('.').pop();
+    const targetFileIsIndex = isIndexPath(targetFile.path);
+    const filePathHash = safeFileName(targetFile.path);
+    const transformedFilePath = `${PROJECT_RELATIVE_PATH}/${targetFileBasePath}/${filePathHash}_${targetFileIsIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${targetFileExtension}`;
+
+    // Check if we've already processed this file as a transitive copy
+    // Note: __data_file_written__ is for entity-specific scenario files with different naming,
+    // but we still need transitive copies for server-only stripping. Data entity files may
+    // only export specific items, so we need a full transitive copy with all exports.
+    const alreadyTransitive = writtenScenarioComponents[
+      resolvedFilePath
+    ]?.includes('__transitive_file_written__');
+
+    if (!alreadyTransitive) {
+      // Ensure content is loaded (LazyFileStore loads content on-demand)
+      if (!targetFile.content && fileStore) {
+        targetFile = await fileStore.ensureContent(resolvedFilePath);
+      }
+      if (!targetFile?.content) {
+        continue;
+      }
+
+      // Get the file content and apply transformations
+      let transformedContent = targetFile.content;
+      transformedContent = stripServerOnlyImport(transformedContent);
+      transformedContent = applyServerOnlyMocks(transformedContent);
+
+      // Recursively process this transitive file's imports
+      // This handles the nested case: service.ts → brevo.ts → constants.ts
+      const nestedImportPaths = extractInternalImportPaths(transformedContent);
+      debugLog(
+        `[NESTED] Processing ${nestedImportPaths.length} nested imports for ${targetFile.path}`,
+      );
+      let nestedIndex = 0;
+      for (const nestedImportPath of nestedImportPaths) {
+        nestedIndex++;
+        debugLog(
+          `[NESTED LOOP] import ${nestedIndex}/${nestedImportPaths.length}: ${nestedImportPath}`,
+        );
+        const nestedResolvedPath = resolveImportPath(
+          nestedImportPath,
+          targetFile.path,
+          project,
+        );
+        if (!nestedResolvedPath) continue;
+
+        // Get file info for building the transformed path
+        let nestedFile = fileStore
+          ? fileStore.getByPath(nestedResolvedPath)
+          : project.files?.find((f) => f.path === nestedResolvedPath);
+        if (!nestedFile) continue;
+
+        // Build the transformed path (needed for import rewriting even if already processed)
+        const nestedBasePath = safeFolder(
+          nestedFile.path.split('/').slice(0, -1).join('/'),
+        );
+        const nestedExtension = nestedFile.name.split('.').pop();
+        const nestedIsIndex = isIndexPath(nestedFile.path);
+        const nestedPathHash = safeFileName(nestedFile.path);
+        const nestedTransformedPath = `${PROJECT_RELATIVE_PATH}/${nestedBasePath}/${nestedPathHash}_${nestedIsIndex ? 'index_' : ''}transitive_${safeFileName(scenario.name)}.${nestedExtension}`;
+
+        // Check if already processed as a transitive file (we can rewrite to point to it)
+        // Note: __data_file_written__ is for entity-specific scenario files with different naming,
+        // but we still need transitive copies for server-only stripping in the import chain
+        const nestedAlreadyTransitive = writtenScenarioComponents[
+          nestedResolvedPath
+        ]?.includes('__transitive_file_written__');
+
+        if (!nestedAlreadyTransitive) {
+          // Ensure content is loaded for nested files
+          if (!nestedFile.content && fileStore) {
+            nestedFile = await fileStore.ensureContent(nestedResolvedPath);
+          }
+          if (!nestedFile?.content) continue;
+
+          // Strip server-only, mock server-only packages, and recursively process imports
+          // This handles chains of any depth: A -> B -> C -> D
+          let nestedContent = stripServerOnlyImport(nestedFile.content);
+          nestedContent = applyServerOnlyMocks(nestedContent);
+          debugLog(
+            `processTransitiveImportsRecursively (nested) for ${nestedFile.path}`,
+          );
+          nestedContent = await withTimeout(
+            `processTransitiveImportsRecursively (nested) for ${path.basename(nestedFile.path)}`,
+            processTransitiveImportsRecursively(
+              nestedContent,
+              nestedFile.path,
+              nestedTransformedPath,
+            ),
+            30000, // 30 second timeout per nested transitive import
+          );
+          debugLog(
+            `Completed processTransitiveImportsRecursively (nested) for ${nestedFile.path}`,
+          );
+
+          await writeFile(nestedTransformedPath, nestedContent);
+          scenarioComponentPaths.push(nestedTransformedPath);
+
+          // Mark as written
+          if (!writtenScenarioComponents[nestedResolvedPath]) {
+            writtenScenarioComponents[nestedResolvedPath] = [];
+          }
+          writtenScenarioComponents[nestedResolvedPath].push(
+            '__transitive_file_written__',
+          );
+        }
+
+        // Rewrite the import to point to the transitive copy
+        const nestedRelativePath = getRelativePath(
+          transformedFilePath,
+          nestedTransformedPath,
+        );
+        // Strip the extension before applying safeFolder - import paths in TypeScript
+        // should NOT include extensions (Next.js resolves .ts/.tsx automatically).
+        // Without this, safeFolder converts ".ts" to "_ts" causing "Module not found" errors.
+        const nestedRelativePathWithoutExt = nestedRelativePath.replace(
+          /\.(ts|tsx|js|jsx)$/,
+          '',
+        );
+        const safeNestedRelativePath = safeFolder(nestedRelativePathWithoutExt);
+        const escapedNestedImportPath = nestedImportPath.replace(
+          /[.*+?^${}()|[\]\\]/g,
+          '\\$&',
+        );
+        const nestedImportRegex = new RegExp(
+          `(from\\s*["'])${escapedNestedImportPath}(["'])`,
+          'g',
+        );
+        transformedContent = transformedContent.replace(
+          nestedImportRegex,
+          `$1${safeNestedRelativePath}$2`,
+        );
+      }
+
+      // Re-check if file was written during recursive processing
+      // (processTransitiveImportsRecursively might have created this file while processing
+      // a nested import that circularly imports back to this file)
+      const writtenDuringRecursion = writtenScenarioComponents[
+        resolvedFilePath
+      ]?.includes('__transitive_file_written__');
+
+      if (!writtenDuringRecursion) {
+        // Write the transformed file
+        await writeFile(transformedFilePath, transformedContent);
+        scenarioComponentPaths.push(transformedFilePath);
+
+        // Mark as written
+        if (!writtenScenarioComponents[resolvedFilePath]) {
+          writtenScenarioComponents[resolvedFilePath] = [];
+        }
+        writtenScenarioComponents[resolvedFilePath].push(
+          '__transitive_file_written__',
+        );
+      }
+    }
+
+    // ALWAYS rewrite the import in fileContent to point to the transformed file
+    // (even if the transitive copy was already created by another entity)
+    const relativePath = getRelativePath(
+      scenarioComponentPath,
+      transformedFilePath,
+    );
+    // Strip the extension before applying safeFolder - import paths in TypeScript
+    // should NOT include extensions (Next.js resolves .ts/.tsx automatically).
+    // Without this, safeFolder converts ".ts" to "_ts" causing "Module not found" errors.
+    const relativePathWithoutExt = relativePath.replace(
+      /\.(ts|tsx|js|jsx)$/,
+      '',
+    );
+    const safeRelativePath = safeFolder(relativePathWithoutExt);
+
+    // Escape special regex characters in the import path
+    const escapedImportPath = importPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const importRegex = new RegExp(
+      `(from\\s*["'])${escapedImportPath}(["'])`,
+      'g',
+    );
+    fileContent = fileContent.replace(importRegex, `$1${safeRelativePath}$2`);
+  }
 
   const scenarioComponentComment = `// This file is auto-generated by CodeYam. Do not edit this file manually.
 // This file contains content for a scenario component:
@@ -909,19 +2699,26 @@ export default async function writeScenarioComponents({
 // Scenario: ${scenario.id} - ${scenario.name}
 `;
 
-  await writeFile(
-    scenarioComponentPath,
-    `${scenarioComponentComment}\n\n${fileContent}`,
-  );
-  scenarioComponentPaths.push(scenarioComponentPath);
+  // 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: string;
+  if (extractedDirective && extractedDirective.includes('client')) {
+    finalContent = `${extractedDirective}\n\n${scenarioComponentComment}\n\n${fileContent}`;
+  } else {
+    finalContent = `${scenarioComponentComment}\n\n${fileContent}`;
+  }
 
-  console.log('CodeYam [writeScenarioComponents]: Generated scenario files', {
-    entityName: entity.name,
-    filePath: file.path,
-    scenarioName: scenario.name,
-    scenarioComponentPathsGenerated: scenarioComponentPaths,
-    writtenScenarioComponentKeys: Object.keys(writtenScenarioComponents),
+  debugLog('About to write final scenario file', {
+    scenarioComponentPath,
+    contentLength: finalContent.length,
   });
+  await writeFile(scenarioComponentPath, finalContent);
+  debugLog('Successfully wrote scenario file');
+  scenarioComponentPaths.push(scenarioComponentPath);
 
   return { scenarioComponentPaths, writtenScenarioComponents };
 }