@codeyam/codeyam-cli 0.1.0-staging.842873f → 0.1.0-staging.8df382d

package/analyzer-template/project/writeScenarioComponents.ts

@@ -25,6 +25,68 @@ 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.
@@ -35,11 +97,15 @@ import { LazyFileStore } from './LazyFileStore';
  */
 function findEndOfImports(content: string): number {
   try {
+    // Use temp.tsx to enable JSX parsing - otherwise TypeScript may misparse
+    // JSX content containing the word "import" (e.g., "Entities that import this")
+    // as an import statement, causing mock code to be inserted in the wrong location.
     const sourceFile = ts.createSourceFile(
-      'temp.ts',
+      'temp.tsx',
       content,
       ts.ScriptTarget.Latest,
       true,
+      ts.ScriptKind.TSX,
     );
 
     let lastImportEnd = 0;
@@ -74,6 +140,125 @@ 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:
@@ -263,10 +448,6 @@ function convertDtsToStubs(content: string, entityName: string): string {
   // Keep export type and export interface statements as-is (they're valid in .ts)
   // No transformation needed for these
 
-  console.log(
-    `CodeYam: Converted .d.ts content for entity "${entityName}". Result length: ${result.length}`,
-  );
-
   return result;
 }
 
@@ -452,10 +633,6 @@ function stripHtmlBodyTags(
     return fileContent;
   }
 
-  console.log(
-    `CodeYam: Stripping <html> and <body> tags from root layout: ${filePath}`,
-  );
-
   // Extract the body className/attributes if any, to preserve styling
   const bodyMatch = fileContent.match(/<body([^>]*)>/);
   const bodyAttributes = bodyMatch?.[1]?.trim() || '';
@@ -501,8 +678,171 @@ function stripHtmlBodyTags(
   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 {
+    // Use temp.tsx to enable JSX parsing for consistent handling of JSX files
+    const sourceFile = ts.createSourceFile(
+      'temp.tsx',
+      fileContent,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TSX,
+    );
+
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement) && statement.moduleSpecifier) {
+        const moduleSpecifier = statement.moduleSpecifier;
+        if (ts.isStringLiteral(moduleSpecifier)) {
+          const importPath = moduleSpecifier.text;
+          // Skip node_modules imports (bare specifiers)
+          if (
+            importPath.startsWith('.') ||
+            importPath.startsWith('@/') ||
+            importPath.startsWith('~/') ||
+            importPath.startsWith('#')
+          ) {
+            importPaths.push(importPath);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(
+      '[extractInternalImportPathsAst] Failed to parse file:',
+      error,
+    );
+  }
+
+  return importPaths;
+}
+
+/**
+ * Resolve an import path to a file path relative to the project.
+ * Handles path aliases like @/, ~/, and relative paths.
+ */
+function resolveImportPath(
+  importPath: 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 === '..') {
+        resolved.pop();
+      } else if (part !== '.' && part !== '') {
+        resolved.push(part);
+      }
+    }
+    resolvedPath = resolved.join('/');
+  } else if (importPath.startsWith('@/') || importPath.startsWith('~/')) {
+    // Path alias - strip the prefix
+    resolvedPath = importPath.slice(2);
+
+    // Infer app prefix from current file path
+    // e.g., if currentFilePath is "apps/web/lib/user/service.ts"
+    // and import is "@/modules/auth/lib/brevo", the actual file is at
+    // "apps/web/modules/auth/lib/brevo.ts"
+    // We detect this by checking if current file starts with "apps/XXX/"
+    const appMatch = currentFilePath.match(/^(apps\/[^/]+\/)/);
+    if (appMatch) {
+      appPrefix = appMatch[1];
+    }
+  } else if (importPath.startsWith('#')) {
+    // Package imports - not supported yet
+    return null;
+  } else {
+    // Unknown format
+    return null;
+  }
+
+  // Try to find the file with various extensions
+  const extensions = ['', '.ts', '.tsx', '.js', '.jsx'];
+
+  // First try with app prefix (for monorepo structures like apps/web/)
+  if (appPrefix) {
+    for (const ext of extensions) {
+      const fullPath = appPrefix + resolvedPath + ext;
+      const file = project.files?.find((f) => f.path === fullPath);
+      if (file) {
+        return file.path;
+      }
+    }
+
+    // Try index files with prefix
+    for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+      const indexPath = `${appPrefix}${resolvedPath}/index${ext}`;
+      const file = project.files?.find((f) => f.path === indexPath);
+      if (file) {
+        return file.path;
+      }
+    }
+  }
+
+  // Then try without prefix (for simpler project structures)
+  for (const ext of extensions) {
+    const fullPath = resolvedPath + ext;
+    const file = project.files?.find((f) => f.path === fullPath);
+    if (file) {
+      return file.path;
+    }
+  }
+
+  // Try index files
+  for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+    const indexPath = `${resolvedPath}/index${ext}`;
+    const file = project.files?.find((f) => f.path === indexPath);
+    if (file) {
+      return file.path;
+    }
+  }
+
+  return null;
+}
+
 // Version for tracking deployments - increment when making changes
-const WRITE_SCENARIO_COMPONENTS_VERSION = '2.1.0-ast-based-import-detection';
+const WRITE_SCENARIO_COMPONENTS_VERSION = '2.5.17-configurable-server-mocks';
 
 function addMockToContent(
   fileContent: string,
@@ -513,9 +853,6 @@ function addMockToContent(
   scenarioName: string,
   importPath?: string,
 ) {
-  console.log(
-    `CodeYam [v${WRITE_SCENARIO_COMPONENTS_VERSION}]: Adding mock for ${importedExport.name} from ${importedExport.filePath}`,
-  );
   // First try to find dependency schemas in fileAnalyses (for same-file dependencies)
   let dependencySchemas = fileAnalyses.find(
     (a) =>
@@ -533,43 +870,72 @@ function addMockToContent(
 
   // Check if we have multiple calls with different variable names
   // This requires generating separate mock functions for each call site
+  //
+  // IMPORTANT: calls array may contain BOTH base hook calls (e.g., "useFetcher<Type>()")
+  // AND method chain usages (e.g., "useFetcher().functionCallReturnValue.submit(...)").
+  // We only want to count base hook calls for the length comparison with callVariableNames.
+  // A "base call" is one that ends with "()" possibly preceded by a type annotation,
+  // without any subsequent method chains like ".functionCallReturnValue" or ".submit(...)".
+  const baseHookCalls = importedExport.calls?.filter((call) => {
+    // Base hook calls match patterns like:
+    // - "useFetcher()"
+    // - "useFetcher<Type>()"
+    // - "useFetcher<{ complex: Type }>()"
+    // They end with "()" and don't have method chains after the call.
+    // Method chains contain ".functionCallReturnValue" or have property access after "()".
+    return (
+      call.endsWith('()') &&
+      !call.includes('.functionCallReturnValue') &&
+      // Also exclude method chains like "hook().something" or "hook().method()"
+      !call.match(/\(\)\.[a-zA-Z]/)
+    );
+  });
+
+  // Determine if we can generate unique mock functions for multiple variables.
+  // We need:
+  // 1. Multiple variable names (callVariableNames.length > 1)
+  // 2. Base hook calls to match them (baseHookCalls.length > 0)
+  // Note: We use min(baseHookCalls.length, callVariableNames.length) for iteration
+  // to handle cases where data might be slightly out of sync (stale entries).
   const hasMultipleCallsWithVariables =
-    importedExport.calls &&
-    importedExport.calls.length > 1 &&
+    baseHookCalls &&
+    baseHookCalls.length > 1 &&
     importedExport.callVariableNames &&
-    importedExport.callVariableNames.length === importedExport.calls.length;
-
-  // DEBUG: Log import info for multiple calls debugging
-  if (
-    importedExport.name === 'useFetcher' ||
-    importedExport.name?.includes('Fetcher')
-  ) {
-    console.log(
-      'CodeYam DEBUG: addMockToContent useFetcher import:',
-      JSON.stringify(
-        {
-          name: importedExport.name,
-          calls: importedExport.calls,
-          callVariableNames: importedExport.callVariableNames,
-          hasMultipleCallsWithVariables,
-          isMocked: importedExport.isMocked,
-        },
-        null,
-        2,
-      ),
-    );
-  }
+    importedExport.callVariableNames.length > 1 &&
+    // Only proceed if we have at least as many base calls as variable names,
+    // OR they're close enough (within 1) to handle minor sync issues
+    Math.abs(baseHookCalls.length - importedExport.callVariableNames.length) <=
+      1;
 
   let mockCode: 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)
+    // Look up canonical keys from dataForMocks and track variable names for function naming
+
+    // Get all call signature keys for this hook from dataForMocks
+    const dataForMocks =
+      rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
+    // Match keys that start with the hook name (e.g., "useFetcher" matches "useFetcher<User>()")
+    const callSignatureKeysForHook = dataForMocks
+      ? Object.keys(dataForMocks).filter((key) => {
+          const hookBaseName = importedExport.name.split(/[<(]/)[0];
+          const keyBaseName = key.split(/[<(]/)[0];
+          return keyBaseName === hookBaseName;
+        })
+      : [];
+
+    // Track variable name occurrences for unique function naming
     const variableNameCounts: Record<string, number> = {};
 
-    for (let i = 0; i < importedExport.calls!.length; i++) {
+    // Use the minimum of both array lengths to handle slight mismatches
+    // (e.g., stale data from previous analysis runs)
+    const iterationLimit = Math.min(
+      baseHookCalls!.length,
+      importedExport.callVariableNames!.length,
+    );
+    for (let i = 0; i < iterationLimit; i++) {
       const variableName = importedExport.callVariableNames![i];
       if (!variableName) continue;
 
@@ -577,18 +943,37 @@ function addMockToContent(
       const occurrence = variableNameCounts[variableName] ?? 0;
       variableNameCounts[variableName] = occurrence + 1;
 
-      // If this is a reused variable name (occurrence > 0), append index
-      // e.g., "fetcher[1] <- useFetcher" for the second usage of "fetcher"
+      // Build indexed variable name for function naming
       const indexedVariableName =
         occurrence > 0 ? `${variableName}[${occurrence}]` : variableName;
 
-      // Generate mock code for this specific call using variable-qualified name
-      // Format: "variableName <- functionName" (reads as "variableName receives from functionName")
-      const qualifiedName = `${indexedVariableName} <- ${importedExport.name}`;
+      // Use safe function name with underscores instead of brackets
+      // e.g., fetcher[1] -> fetcher_1
+      const safeFunctionName = indexedVariableName.replace(/\[(\d+)\]/g, '_$1');
+      // Compute unique mock function name for call site replacement
+      // e.g., useFetcher_entityDiffFetcher, useFetcher_reportFetcher
+      const mockFunctionName = `${importedExport.name}_${safeFunctionName}`;
+
+      // Use the call signature from baseHookCalls[i] as the data key
+      // This matches what's stored in dataForMocks
+      const callSignature = baseHookCalls![i];
+
+      // Generate mock code using the call signature directly
+      // This prevents "symbol already declared" errors when multiple calls exist
+      // Check if this is a package import that won't have scenario copies
+      const isPackageImportForMock = importPath?.startsWith('@');
       const variableMockCode = constructMockCode(
-        qualifiedName,
+        callSignature, // Use call signature format for data lookup
         dependencySchemas,
         importedExport.entityType,
+        undefined, // No need for separate canonical key
+        {
+          uniqueFunctionSuffix: safeFunctionName, // Use variable name for unique function naming
+          // For node_modules or package imports, skip spreading from __cyOriginal
+          // since those packages/files don't export *__cyOriginal variants
+          skipOriginalSpread:
+            importedExport.isNodeModule || isPackageImportForMock,
+        },
       );
 
       if (variableMockCode) {
@@ -597,25 +982,25 @@ function addMockToContent(
         // 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)
+        // Create regex that matches the call (with optional whitespace variations).
+        // TypeScript formatters commonly break type parameters across lines, e.g.:
+        //   useLoaderData<
+        //     typeof loader
+        //   >()
+        // So we allow optional whitespace around < and > delimiters, not just
+        // where whitespace already exists in the call signature string.
         const callRegex = new RegExp(
-          escapedCallSignature.replace(/\s+/g, '\\s*'),
-          'g',
+          escapedCallSignature
+            .replace(/\s+/g, '\\s*')
+            .replace(/</g, '\\s*<\\s*')
+            .replace(/>/g, '\\s*>\\s*'),
+          'gs',
         );
-        // 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}()`);
       }
     }
@@ -631,61 +1016,172 @@ function addMockToContent(
         : undefined;
 
     if (singleCallVariableName) {
-      // For single variable assignments, use the variable-qualified key for data lookup
-      // but keep the original function name (no need for unique function names when there's only one assignment)
-      const qualifiedKey = `${singleCallVariableName} <- ${importedExport.name}`;
-      mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${qualifiedKey}"];
+      // For single variable assignments, use the call signature directly from dataForMocks
+      const dataForMocks =
+        rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
+
+      // Find matching call signature key in dataForMocks
+      // IMPORTANT: First try exact match with type parameters (e.g., "useLoaderData<LoaderData>()")
+      // to avoid picking the wrong variant (e.g., "useLoaderData<typeof loader>()" which may
+      // have different properties). Fall back to base name matching only if exact match fails.
+      const hookBaseName = importedExport.name.split(/[<(]/)[0];
+      const expectedKey = importedExport.calls?.[0];
+      let callSignatureKey: string | undefined;
+
+      if (dataForMocks) {
+        const keys = Object.keys(dataForMocks);
+
+        // First try exact match with the expected call signature
+        if (expectedKey && keys.includes(expectedKey)) {
+          callSignatureKey = expectedKey;
+        } else {
+          // Fall back to base name matching
+          callSignatureKey = keys.find((key) => {
+            // Split on ., <, or ( to get the true base name
+            // This handles both "useFlags()" -> "useFlags" and "trpc.useUtils()" -> "trpc"
+            const keyBaseName = key.split(/[.<(]/)[0];
+            return keyBaseName === hookBaseName;
+          });
+        }
+      }
 
-function ${importedExport.name}() {
-  return ${importedExport.name}ReturnValue;
+      // Use the call signature if found, otherwise construct it
+      const dataKey =
+        callSignatureKey ??
+        importedExport.calls?.[0] ??
+        `${importedExport.name}()`;
+
+      // IMPORTANT: If the dataKey is a method chain (e.g., "trpc.useUtils()"), we should
+      // use the base name (e.g., "trpc") when calling constructMockCode. This ensures
+      // constructMockCode generates a complete nested mock from the schema without
+      // referencing __cyOriginal variables.
+      const dataKeyBaseName = dataKey.split(/[.<(]/)[0];
+      const isMethodChainDataKey =
+        dataKeyBaseName === importedExport.name &&
+        dataKey !== importedExport.name &&
+        dataKey.includes('.');
+      const mockNameToUse = isMethodChainDataKey
+        ? importedExport.name
+        : dataKey;
+
+      // Keep the original function name since there's only one call
+      // Check if this is a package import that won't have scenario copies
+      const isPackageImportForSingleCall = importPath?.startsWith('@');
+      mockCode = constructMockCode(
+        mockNameToUse,
+        dependencySchemas,
+        importedExport.entityType,
+        undefined,
+        {
+          keepOriginalFunctionName: true,
+          // For node_modules or package imports, skip spreading from __cyOriginal
+          // since those packages/files don't export *__cyOriginal variants
+          skipOriginalSpread:
+            importedExport.isNodeModule || isPackageImportForSingleCall,
+        },
+      );
+      // If constructMockCode didn't generate code, fall back to simple return
+      // IMPORTANT: We inline scenarios().data() inside the function rather than
+      // storing in a const - see comment in constructMockCode.ts for why.
+      if (!mockCode) {
+        mockCode = `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)
+const _${importedExport.name}Ref = {
+  current: null,
+};
+function ${importedExport.name}(...args) {
+  if (!_${importedExport.name}Ref.current) {
+    _${importedExport.name}Ref.current = scenarios().data()?.["${dataKey}"];
+  }
+  return _${importedExport.name}Ref.current;
 }`;
+      }
     } else {
-      // 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;
-          }
+      // Helper to find matching call signature key from dataForMocks
+      // IMPORTANT: First try exact match with type parameters (e.g., "useLoaderData<LoaderData>()")
+      // to avoid picking the wrong variant. Fall back to base name matching only if needed.
+      const hookBaseName = importedExport.name.split(/[<(]/)[0];
+      const expectedKey = importedExport.calls?.[0];
+      const findMatchingKey = (
+        dataForMocks: Record<string, unknown> | undefined,
+      ): string | undefined => {
+        if (!dataForMocks) return undefined;
+        const keys = Object.keys(dataForMocks);
+
+        // First try exact match with the expected call signature
+        if (expectedKey && keys.includes(expectedKey)) {
+          return expectedKey;
         }
-      }
 
-      // 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;
-          });
+        // Fall back to base name matching
+        return keys.find((key) => {
+          // Split on ., <, or ( to get the true base name
+          // This handles both "useFlags()" -> "useFlags" and "trpc.useUtils()" -> "trpc"
+          const keyBaseName = key.split(/[.<(]/)[0];
+          return keyBaseName === hookBaseName;
+        });
+      };
+
+      // Check rootAnalysis FIRST for matching keys.
+      // The mock DATA is generated from rootAnalysis, so the mock CODE must
+      // also use rootAnalysis keys to ensure the lookup succeeds.
+      let dataKey = findMatchingKey(
+        rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks,
+      );
+
+      // If not found in rootAnalysis, fall back to fileAnalyses
+      if (!dataKey) {
+        for (const analysis of fileAnalyses) {
+          dataKey = findMatchingKey(
+            analysis.metadata?.scenariosDataStructure?.dataForMocks,
+          );
+          if (dataKey) break;
         }
       }
 
-      if (variableQualifiedKey) {
-        // Use the variable-qualified key found in the analysis
-        mockCode = `const ${importedExport.name}ReturnValue = scenarios().data()?.["${variableQualifiedKey}"];
-
-function ${importedExport.name}() {
-  return ${importedExport.name}ReturnValue;
+      // Use the data key if found, otherwise use call signature or function name.
+      // IMPORTANT: If the dataKey is a method chain (e.g., "trpc.useUtils()"), we should
+      // use the base name (e.g., "trpc") when calling constructMockCode. This ensures
+      // constructMockCode generates a complete nested mock from the schema without
+      // referencing __cyOriginal variables. The __cyOriginal pattern is only needed
+      // for partial mocking where we preserve some original methods, not for complete
+      // method-chain mocks where we provide all implementations.
+      const dataKeyBaseName = dataKey?.split(/[.<(]/)[0];
+      const isMethodChainDataKey =
+        dataKey &&
+        dataKeyBaseName === importedExport.name &&
+        dataKey !== importedExport.name &&
+        dataKey.includes('.');
+      const mockNameToUse = isMethodChainDataKey
+        ? importedExport.name
+        : (dataKey ?? importedExport.calls?.[0] ?? `${importedExport.name}()`);
+
+      mockCode = constructMockCode(
+        mockNameToUse,
+        dependencySchemas,
+        importedExport.entityType,
+        undefined,
+        {
+          keepOriginalFunctionName: true,
+          // For node_modules or package imports, skip spreading from __cyOriginal
+          // since those packages/files don't export *__cyOriginal variants
+          skipOriginalSpread:
+            importedExport.isNodeModule || importPath?.startsWith('@'),
+        },
+      );
+      // If constructMockCode didn't generate code, fall back to simple return
+      // IMPORTANT: We inline scenarios().data() inside the function rather than
+      // storing in a const - see comment in constructMockCode.ts for why.
+      if (!mockCode && dataKey) {
+        mockCode = `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)
+const _${importedExport.name}Ref = {
+  current: null,
+};
+function ${importedExport.name}(...args) {
+  if (!_${importedExport.name}Ref.current) {
+    _${importedExport.name}Ref.current = scenarios().data()?.["${dataKey}"];
+  }
+  return _${importedExport.name}Ref.current;
 }`;
-      } else {
-        // Original behavior for calls without variable names
-        mockCode = constructMockCode(
-          importedExport.name,
-          dependencySchemas,
-          importedExport.entityType,
-        );
       }
     }
   }
@@ -695,35 +1191,6 @@ function ${importedExport.name}() {
     variableMockCodes.length > 0 ? variableMockCodes.join('\n\n') : mockCode;
 
   if (!allMockCodes) {
-    console.log(
-      'CodeYam Error: Mock code not found',
-      JSON.stringify(
-        {
-          importedExportFilePath: importedExport.filePath,
-          importedExportEntityName: importedExport.name,
-          hasMultipleCallsWithVariables,
-          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,
-      ),
-    );
-
     return fileContent;
   }
 
@@ -745,12 +1212,39 @@ function ${importedExport.name}() {
         /[.*+?^${}()|[\]\\]/g,
         '\\$&',
       );
+      // Use a simpler, more robust regex pattern that matches the fallback path.
+      // Key improvements:
+      // 1. Uses escapeRegExp(firstPart) to handle special characters in function names
+      // 2. Uses word boundaries (\b) to prevent partial matches
+      // 3. Handles comma BEFORE or AFTER the name: (?:,\s*|\s*,)?
+      // 4. Matches specific import path (escapedImportPath)
       const importRegExp = new RegExp(
-        `(import(?:(?!${firstPart}|from|import)[\\s\\S])*?)${firstPart}(?:,\\s*)?((?:(?!import)[\\s\\S])*?from\\s+['"]${escapedImportPath}['"])`,
+        `(import\\s*\\{[^}]*?)\\b${escapeRegExp(firstPart)}\\b(?:,\\s*|\\s*,)?((?:[^}]*\\}\\s*from\\s*['"]${escapedImportPath}['"];?))`,
         'm',
       );
 
-      if (importedExportNameParts.length > 1) {
+      // Check if any call signature has multiple parts (e.g., "logger.error(error)")
+      // If so, the mock code will spread from __cyOriginal, so we need to rename the import
+      // EXCEPT:
+      // 1. For node_module imports, the __cyOriginal pattern doesn't work because
+      //    the original package doesn't export *__cyOriginal variants.
+      // 2. For package imports (starting with @), the __cyOriginal pattern doesn't work
+      //    because scenario copies aren't created for package files - they keep the
+      //    original import path which doesn't export *__cyOriginal.
+      const anyCallHasMultipleParts = importedExport.calls?.some((call) => {
+        const callParts = splitOutsideParenthesesAndArrays(call);
+        return callParts.length > 1;
+      });
+
+      // Package imports (starting with @) don't get scenario copies, so __cyOriginal won't exist
+      const isPackageImport = importPath.startsWith('@');
+
+      const shouldRenameToOriginal =
+        !importedExport.isNodeModule &&
+        !isPackageImport &&
+        (importedExportNameParts.length > 1 || anyCallHasMultipleParts);
+
+      if (shouldRenameToOriginal) {
         fileContent = fileContent.replace(
           importRegExp,
           `$1${firstPart}__cyOriginal$2`,
@@ -759,6 +1253,21 @@ function ${importedExport.name}() {
         fileContent = fileContent.replace(importRegExp, '$1$2');
       }
 
+      // Also handle namespace imports (import * as foo from '...')
+      // These need to be renamed to foo__cyOriginal when the mock code spreads from the original.
+      // Note: We match any path (not just escapedImportPath) because the import path may have
+      // been rewritten by transitive import handling before this code runs.
+      if (shouldRenameToOriginal) {
+        const namespaceImportRegExp = new RegExp(
+          `(import\\s+\\*\\s+as\\s+)${escapeRegExp(firstPart)}(\\s+from\\s+['"][^'"]*['"])`,
+          'm',
+        );
+        fileContent = fileContent.replace(
+          namespaceImportRegExp,
+          `$1${firstPart}__cyOriginal$2`,
+        );
+      }
+
       // Remove empty imports entirely to avoid partial commenting issues with multiline imports
       // This handles both single-line and multiline empty imports
       fileContent = fileContent.replace(
@@ -783,7 +1292,20 @@ function ${importedExport.name}() {
       'm',
     );
 
-    if (importedExportNameParts.length > 1) {
+    // Check if any call signature has multiple parts (e.g., "logger.error(error)")
+    // If so, the mock code will spread from __cyOriginal, so we need to rename the import
+    // EXCEPT: For node_module imports, the __cyOriginal pattern doesn't work because
+    // the original package doesn't export *__cyOriginal variants.
+    const anyCallHasMultipleParts = importedExport.calls?.some((call) => {
+      const callParts = splitOutsideParenthesesAndArrays(call);
+      return callParts.length > 1;
+    });
+
+    const shouldRenameToOriginal =
+      !importedExport.isNodeModule &&
+      (importedExportNameParts.length > 1 || anyCallHasMultipleParts);
+
+    if (shouldRenameToOriginal) {
       // Rename the import instead of removing (for destructured access patterns)
       fileContent = fileContent.replace(
         namedImportRegExp,
@@ -818,18 +1340,12 @@ function ${importedExport.name}() {
 
   if (lastImportEnd > 0) {
     // Insert after the last original import
-    console.log(
-      `CodeYam [v${WRITE_SCENARIO_COMPONENTS_VERSION}]: Inserting mock at position ${lastImportEnd} (after imports), not at end`,
-    );
     fileContent =
       fileContent.slice(0, lastImportEnd) +
       insertContent +
       fileContent.slice(lastImportEnd);
   } else {
     // Fallback: append at end if no imports found
-    console.log(
-      `CodeYam [v${WRITE_SCENARIO_COMPONENTS_VERSION}]: No imports found, appending mock at end`,
-    );
     fileContent += insertContent;
   }
 
@@ -1011,6 +1527,15 @@ export default async function writeScenarioComponents({
   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,
@@ -1132,9 +1657,6 @@ export default async function writeScenarioComponents({
   // .d.ts files only have type declarations (e.g., "export declare const logger")
   // which don't provide runtime exports. We need to generate actual stub implementations.
   if (file.path.endsWith('.d.ts')) {
-    console.log(
-      `CodeYam: Converting .d.ts file to stub implementations: ${file.path}`,
-    );
     fileContent = convertDtsToStubs(fileContent, entity.name);
 
     // After basic .d.ts conversion, enhance the entity's stub with proper mock code
@@ -1233,7 +1755,31 @@ export default async function writeScenarioComponents({
     return 0;
   });
 
+  debugLog('Starting main importedExports loop', {
+    count: sortedImportedExports.length,
+    fileContentLength: fileContent.length,
+  });
+
+  let importedExportIndex = 0;
+  const loopStartTime = Date.now();
+  console.log(
+    `[WriteScenario] Starting import loop for ${entity.name}: ${sortedImportedExports.length} imports`,
+  );
   for (const importedExport of sortedImportedExports) {
+    importedExportIndex++;
+    if (importedExportIndex % 5 === 0 || importedExportIndex === 1) {
+      console.log(
+        `[WriteScenario] ${entity.name} import ${importedExportIndex}/${sortedImportedExports.length}: ${importedExport.name} elapsed=${Date.now() - loopStartTime}ms`,
+      );
+      debugLog(
+        `Processing importedExport ${importedExportIndex}/${sortedImportedExports.length}`,
+        {
+          name: importedExport.name,
+          filePath: importedExport.filePath,
+          isMocked: importedExport.isMocked,
+        },
+      );
+    }
     // IMPORTANT: The import mapping keys may be either absolute or relative paths
     // depending on how they were created by the file analyzer. We try multiple formats.
     // Also need to normalize paths to handle /tmp vs /private/tmp on macOS
@@ -1305,15 +1851,6 @@ export default async function writeScenarioComponents({
             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)
@@ -1347,35 +1884,126 @@ export default async function writeScenarioComponents({
             fileNotMocked = await fileStore.ensureContent(fileNotMocked.path);
           }
 
-          // When a default export is imported as named (via index re-export), we need
-          // to add a named re-export to the scenario component so the import works.
-          // e.g., if file has `export default X` but parent does `import { X } from '...'`
-          const needsNamedReExport =
-            importedExport.resolvedIsDefault === true &&
-            importedExport.isDefault === false;
-
-          const {
-            scenarioComponentPaths: newScenarioComponentPaths,
-            writtenScenarioComponents: updatedWrittenScenarioComponents,
-          } = await writeScenarioComponents({
-            project,
-            file: fileNotMocked,
-            entity: importedExportEntity,
-            rootAnalysis,
-            scenario,
-            context,
-            projectAnalyzer,
-            framework,
-            mocksDir,
-            rootFile,
-            namespaceMocks,
-            writtenScenarioComponents,
-            fileStore,
-            // Pass the import name so we can add `export { default as Name };`
-            exportAsNamed: needsNamedReExport ? importedExport.name : undefined,
-          });
-          writtenScenarioComponents = updatedWrittenScenarioComponents;
-          scenarioComponentPaths.push(...newScenarioComponentPaths);
+          // For type/data entities, create a transformed copy WITHOUT recursion.
+          // Data entities don't need mocking - they're just constants/types that need
+          // to be available. But we still need to:
+          // 1. Strip server-only imports (Next.js directive that breaks client components)
+          // 2. Write the transformed file so imports can be rewritten to point to it
+          if (
+            importedExportEntity.entityType === 'type' ||
+            importedExportEntity.entityType === 'data'
+          ) {
+            // For data entities, we write ONE transformed copy per source file, not per entity.
+            // Check if we've already written ANY entity from this file - if so, skip writing.
+            // Use a special marker '__data_file_written__' to track file-level writes.
+            // Also track which SHA was used via '__data_file_sha__:xxx' so subsequent
+            // entities from the same file can reuse it for import rewriting.
+            const dataFileWritten = writtenScenarioComponents[
+              importedExportFilePath
+            ]?.includes('__data_file_written__');
+
+            if (!dataFileWritten) {
+              // Construct the scenario file path for the data file
+              // Use a file-level identifier (first entity's sha) for consistency
+              const dataFileBasePath = safeFolder(
+                fileNotMocked.path.split('/').slice(0, -1).join('/'),
+              );
+              const dataFileExtension = fileNotMocked.name.split('.').pop();
+              const dataFileIsIndex = isIndexPath(fileNotMocked.path);
+              // Use 'data' prefix to distinguish from entity-specific files
+              const dataScenarioPath = `${PROJECT_RELATIVE_PATH}/${dataFileBasePath}/${importedExportEntity.sha}_${dataFileIsIndex ? 'index_' : ''}data_${safeFileName(scenario.name)}.${dataFileExtension}`;
+
+              // Get the file content and apply transformations
+              let dataFileContent = fileNotMocked.content ?? '';
+
+              // Strip server-only imports - these break when imported by client components
+              dataFileContent = stripServerOnlyImport(dataFileContent);
+              dataFileContent = applyServerOnlyMocks(dataFileContent);
+
+              // Write the transformed data entity file
+              await writeFile(dataScenarioPath, dataFileContent);
+              scenarioComponentPaths.push(dataScenarioPath);
+
+              // Mark file as written so we don't duplicate for other entities from same file
+              if (!writtenScenarioComponents[importedExportFilePath]) {
+                writtenScenarioComponents[importedExportFilePath] = [];
+              }
+              writtenScenarioComponents[importedExportFilePath].push(
+                '__data_file_written__',
+              );
+              // Also store the SHA used for this data file so subsequent entities can use it
+              writtenScenarioComponents[importedExportFilePath].push(
+                `__data_file_sha__:${importedExportEntity.sha}`,
+              );
+            }
+
+            // Mark this specific entity as written (for the entity-level check)
+            if (!writtenScenarioComponents[importedExportFilePath]) {
+              writtenScenarioComponents[importedExportFilePath] = [];
+            }
+            writtenScenarioComponents[importedExportFilePath].push(
+              importedExport.name,
+            );
+
+            // Don't recurse - data entities don't need their dependencies processed
+            // The import rewriting will happen later in this same loop iteration
+            // (at lines ~1590-1702) to point imports to this transformed file
+          } else {
+            // For visual/library entities, recurse to process their dependencies
+
+            // When a default export is imported as named (via index re-export), we need
+            // to add a named re-export to the scenario component so the import works.
+            // e.g., if file has `export default X` but parent does `import { X } from '...'`
+            const needsNamedReExport =
+              importedExport.resolvedIsDefault === true &&
+              importedExport.isDefault === false;
+
+            console.log(
+              `[WriteScenario] RECURSE START: ${entity.name} -> ${importedExportEntity.name}`,
+            );
+            const recurseStartTime = Date.now();
+            debugLog(
+              `Recursing into writeScenarioComponents for ${importedExportEntity.name}`,
+              {
+                entityName: importedExportEntity.name,
+                filePath: fileNotMocked.path,
+              },
+            );
+            const {
+              scenarioComponentPaths: newScenarioComponentPaths,
+              writtenScenarioComponents: updatedWrittenScenarioComponents,
+            } = await withTimeout(
+              `recursive writeScenarioComponents for ${importedExportEntity.name}`,
+              writeScenarioComponents({
+                project,
+                file: fileNotMocked,
+                entity: importedExportEntity,
+                rootAnalysis,
+                scenario,
+                context,
+                projectAnalyzer,
+                framework,
+                mocksDir,
+                rootFile,
+                namespaceMocks,
+                writtenScenarioComponents,
+                fileStore,
+                // Pass the import name so we can add `export { default as Name };`
+                exportAsNamed: needsNamedReExport
+                  ? importedExport.name
+                  : undefined,
+              }),
+              180000, // 3 minute timeout for recursive calls (complex components need more time)
+            );
+            console.log(
+              `[WriteScenario] RECURSE END: ${entity.name} -> ${importedExportEntity.name} took ${Date.now() - recurseStartTime}ms`,
+            );
+            debugLog(
+              `Completed recursive writeScenarioComponents for ${importedExportEntity.name}`,
+            );
+            writtenScenarioComponents = updatedWrittenScenarioComponents;
+            scenarioComponentPaths.push(...newScenarioComponentPaths);
+          }
         }
       }
     } else if (
@@ -1392,26 +2020,25 @@ export default async function writeScenarioComponents({
       // 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,
-          ),
-        );
-
-      if (looksLikeZodSchema) {
-        console.log(
-          `CodeYam: Detected Zod schema "${importedExport.name}" (misclassified as library) - will preserve`,
-        );
-      }
+      // If calls data shows the entity is only accessed via properties/methods
+      // (e.g., formValidator.validate(), schema.superRefine()) and never directly
+      // invoked (e.g., getInitialProps()), it's used as an object and should be
+      // preserved rather than replaced with a Proxy stub.
+      const onlyPropertyAccessed =
+        importedExport.calls?.length > 0 &&
+        !importedExport.calls.some((call: string) => {
+          const afterName = call.slice(importedExport.name.length);
+          return afterName.startsWith('(') || afterName.startsWith('<');
+        });
 
-      // Callable entities can be safely stubbed (but not Zod schemas)
+      // Callable entities can be safely stubbed. Entities that are only
+      // property-accessed should be preserved (their methods need to work).
+      // 'other' entities are unknown types — safer to preserve than stub.
       const isCallable =
-        !isDataEntity && !looksLikeZodSchema && entityType !== undefined;
+        !isDataEntity &&
+        !onlyPropertyAccessed &&
+        entityType !== undefined &&
+        entityType !== 'other';
 
       // Determine what action to take
       const shouldStripAndReplace = hasMock;
@@ -1431,9 +2058,6 @@ export default async function writeScenarioComponents({
       if (shouldPreserve) {
         // For data entities (like Zod schemas), don't strip or stub - preserve the original
         // This ensures schema methods like .superRefine() continue to work
-        console.log(
-          `CodeYam: Preserving ${importedExport.name} (entityType: ${entityType}) - not stripping data entities`,
-        );
         // Don't modify fileContent - keep the original code
       } else if (shouldStripAndReplace || shouldStripAndStub) {
         // Strip the original code
@@ -1457,9 +2081,6 @@ export default async function writeScenarioComponents({
           // This prevents ReferenceError at runtime when the stripped
           // function is called (e.g., local helper functions like getInitialProps).
           const functionName = importedExport.name;
-          console.log(
-            `CodeYam: Generating stub mock for ${functionName} (entityType: ${entityType}) in ${file.path}`,
-          );
 
           // Add scenarios import if not present
           if (fileContent.indexOf('import { scenarios } from') === -1) {
@@ -1594,6 +2215,31 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
 
       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,
@@ -1615,7 +2261,7 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
             .join('.')
         : 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));
@@ -1656,21 +2302,33 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
           // This handles cases where multiple entities are imported from the same index file
           // (e.g., import { A, B, C } from '@pkg') and each has its own scenario file
           const entityImportName = importedExport.name;
-          const newImport = `import { ${entityImportName} } from '${path}';`;
+          // Use default import syntax for default exports, named import for named exports
+          const newImport = importedExport.isDefault
+            ? `import ${entityImportName} from '${path}';`
+            : `import { ${entityImportName} } from '${path}';`;
 
           // First, try to remove this entity from the already-rewritten grouped import
           // This prevents duplicate/conflicting imports
-          // Match patterns like "EntityName," or ", EntityName" or "EntityName" (if only one)
-          // Note: entityImportName needs escaping since JS identifiers can contain $ (a regex metacharacter)
+          // Use AST-based removal to properly handle type-only imports like `type EntityName`
           const escapedEntityName = escapeRegExp(entityImportName);
-          const removeFromGroupedImportPatterns = [
-            new RegExp(`\\b${escapedEntityName}\\s*,\\s*`, 'g'), // "EntityName, "
-            new RegExp(`\\s*,\\s*${escapedEntityName}\\b`, 'g'), // ", EntityName"
-          ];
-          for (const pattern of removeFromGroupedImportPatterns) {
-            fileContent = fileContent.replace(pattern, '');
+
+          // For default imports: remove "DefaultName, " from "import DefaultName, { ... }"
+          // This handles the case where a default export is being split out
+          if (importedExport.isDefault) {
+            const defaultImportPattern = new RegExp(
+              `(import\\s+)${escapedEntityName}\\s*,\\s*(\\{)`,
+              'gm',
+            );
+            fileContent = fileContent.replace(defaultImportPattern, '$1$2');
           }
 
+          // Remove the named import using AST parsing
+          // This properly handles:
+          // - Regular imports: `import { EntityName } from '...'`
+          // - Type-only imports: `import { type EntityName } from '...'`
+          // - Mixed imports: `import { type EntityName, OtherName } from '...'`
+          fileContent = removeNamedImportAst(fileContent, entityImportName);
+
           // Add the new import at the beginning of fileContent
           // Note: The header comment (// Scenario:) doesn't exist yet - it's prepended at writeFile time
           // So prepending here puts the import right after the header in the final output
@@ -1685,9 +2343,32 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     }
   }
 
+  // Track post-import-loop timing
+  const postLoopStartTime = Date.now();
+  console.log(`[WriteScenario] POST-LOOP START: ${entity.name}`);
+
+  // Collect universal mocks BEFORE processing nodeModuleImports
+  // This is needed to check if a node module import is handled by a universal mock
+  const universalMocks = project.metadata?.universalMocks ?? [];
+  const nodeModuleUniversalMocks = universalMocks.filter(
+    (mock) => mock.nodeModule && mock.content,
+  );
+
+  // Create a set of import paths that have universal mocks for quick lookup
+  const universalMockPaths = new Set(
+    nodeModuleUniversalMocks.map((mock) => mock.filePath),
+  );
+
   for (const nodeModuleImport of nodeModuleImports) {
     if (!nodeModuleImport.isMocked) continue;
 
+    // Skip generating local mock functions for imports that have universal mocks.
+    // Universal mocks provide the exports via rewritten import paths (handled below).
+    // Generating a local mock function would cause "name defined multiple times" errors.
+    if (universalMockPaths.has(nodeModuleImport.filePath)) {
+      continue;
+    }
+
     fileContent = addMockToContent(
       fileContent,
       nodeModuleImport,
@@ -1703,10 +2384,6 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
   // 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;
@@ -1729,6 +2406,10 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     );
   }
 
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: node+universal mocks took ${Date.now() - postLoopStartTime}ms`,
+  );
+
   if (
     rootAnalysis.entitySha === entity.sha &&
     entity.metadata?.notExported &&
@@ -1770,33 +2451,540 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     });
   }
 
+  debugLog('Route path computed', { scenarioComponentPath });
+
   // Strip <html> and <body> tags from root layout files for Next.js
   // These tags cause hydration errors when the scenario layout is nested under the real root
+  debugLog('Starting stripHtmlBodyTags');
   fileContent = stripHtmlBodyTags(fileContent, file.path, framework);
+  debugLog('Completed stripHtmlBodyTags');
+
+  // Strip "server-only" imports for Next.js
+  // These cause errors when the scenario component is rendered client-side
+  debugLog('Starting stripServerOnlyImport');
+  fileContent = stripServerOnlyImport(fileContent);
+  debugLog('Starting applyServerOnlyMocks');
+  fileContent = applyServerOnlyMocks(fileContent);
+  debugLog('Completed server-only processing');
 
   // Rewrite asset imports (CSS, images, fonts, etc.) to correct relative paths
   // The original file path is relative to PROJECT_RELATIVE_PATH, the new path is scenarioComponentPath
+  debugLog('Starting rewriteAssetImports');
   fileContent = rewriteAssetImports(
     fileContent,
     `${PROJECT_RELATIVE_PATH}/${file.path}`,
     scenarioComponentPath,
   );
+  debugLog('Completed rewriteAssetImports');
 
   // Rewrite relative TypeScript/JavaScript module imports to correct relative paths
   // This handles cases where the file is moved (e.g., from [environmentId]/ to _environmentId_/)
   // and relative imports like "./lib/organization" need to be rewritten
+  debugLog('Starting rewriteRelativeModuleImports');
   fileContent = rewriteRelativeModuleImports(
     fileContent,
     `${PROJECT_RELATIVE_PATH}/${file.path}`,
     scenarioComponentPath,
   );
+  debugLog('Completed rewriteRelativeModuleImports');
 
   console.log(
-    'Writing scenario component',
-    file.path,
-    entity.name,
-    scenarioComponentPath,
-    fileContent.length,
+    `[WriteScenario] POST-LOOP ${entity.name}: transformations took ${Date.now() - postLoopStartTime}ms`,
+  );
+
+  /**
+   * Recursively process a file's imports to create transitive copies with server-only stripped.
+   * This handles chains of arbitrary depth: A -> B -> C -> D where each needs server-only removed.
+   * Uses a visited set to detect and break circular import chains.
+   *
+   * @param content - The file content to process
+   * @param sourceFilePath - The original source file path (for resolving relative imports)
+   * @param targetFilePath - The path where this content will be written (for computing relative imports)
+   * @param visitedPaths - Set of file paths currently being processed (for cycle detection)
+   * @returns The modified content with imports rewritten to point to transitive copies
+   */
+  async function processTransitiveImportsRecursively(
+    content: 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 = 180000; // 3 minutes max for all transitive processing (complex components need more time)
+    const elapsed = Date.now() - startTime;
+    if (elapsed > GLOBAL_TIMEOUT_MS) {
+      throw new Error(
+        `processTransitiveImportsRecursively exceeded ${GLOBAL_TIMEOUT_MS}ms (elapsed: ${elapsed}ms) at depth=${depth} for ${sourceFilePath}`,
+      );
+    }
+
+    const importPaths = extractInternalImportPaths(content);
+    // Always log to help debug timeout issues
+    console.log(
+      `[TransitiveImports] depth=${depth} file=${path.basename(sourceFilePath)} imports=${importPaths.length} visited=${visitedPaths.size} elapsed=${Date.now() - startTime}ms`,
+    );
+    debugLog(`processTransitiveImportsRecursively depth=${depth}`, {
+      sourceFilePath,
+      importCount: importPaths.length,
+      visitedCount: visitedPaths.size,
+    });
+    let modifiedContent = content;
+
+    // Safety check: limit iterations to prevent infinite loops
+    const MAX_IMPORTS_PER_FILE = 100;
+    if (importPaths.length > MAX_IMPORTS_PER_FILE) {
+      console.warn(
+        `[WriteScenario] WARNING: File ${sourceFilePath} has ${importPaths.length} imports (> ${MAX_IMPORTS_PER_FILE}), limiting processing`,
+      );
+    }
+
+    let importIndex = 0;
+    debugLog(
+      `Starting import loop at depth=${depth}, ${importPaths.length} imports to process`,
+    );
+    const slicedImports = importPaths.slice(0, MAX_IMPORTS_PER_FILE);
+    for (const importPath of slicedImports) {
+      if (!importPath) {
+        continue;
+      }
+      importIndex++;
+      debugLog(
+        `[LOOP] depth=${depth} import ${importIndex}/${Math.min(importPaths.length, MAX_IMPORTS_PER_FILE)}: ${importPath}`,
+      );
+      debugLog(`[LOOP] Calling resolveImportPath...`);
+      const resolvedPath = resolveImportPath(
+        importPath,
+        sourceFilePath,
+        project,
+      );
+      debugLog(
+        `[LOOP] resolveImportPath returned: ${resolvedPath?.slice(0, 80) ?? 'null'}`,
+      );
+      if (!resolvedPath) continue;
+
+      debugLog(`[LOOP] Looking up importFile...`);
+      let importFile = fileStore
+        ? fileStore.getByPath(resolvedPath)
+        : project.files?.find((f) => f.path === resolvedPath);
+      debugLog(
+        `[LOOP] importFile lookup result: ${importFile ? 'found' : 'not found'}`,
+      );
+      if (!importFile) continue;
+
+      // Build the transitive file path (needed for import rewriting even if we skip creating)
+      const basePath = safeFolder(
+        importFile.path.split('/').slice(0, -1).join('/'),
+      );
+      const extension = importFile.name.split('.').pop();
+      const isIndex = isIndexPath(importFile.path);
+      // Limit pathHash length to prevent ENAMETOOLONG errors on macOS (255 char limit)
+      const pathHash = safeFileName(importFile.path, { maxLength: 80 });
+      const scenarioSlug = safeFileName(scenario.name, { maxLength: 60 });
+      const transitiveFilePath = `${PROJECT_RELATIVE_PATH}/${basePath}/${pathHash}_${isIndex ? 'index_' : ''}transitive_${scenarioSlug}.${extension}`;
+
+      // Check if this is a circular import (we're already processing this file)
+      const isCircularImport = visitedPaths.has(resolvedPath);
+
+      // Check if already processed
+      const alreadyProcessed = writtenScenarioComponents[
+        resolvedPath
+      ]?.includes('__transitive_file_written__');
+
+      // Only create the transitive file if not circular and not already processed
+      if (!isCircularImport && !alreadyProcessed) {
+        // Load content if needed
+        if (!importFile.content && fileStore) {
+          importFile = await fileStore.ensureContent(resolvedPath);
+        }
+        if (!importFile?.content) {
+          // Can't create transitive, but still try to rewrite import below
+        } else {
+          // Mark as being processed BEFORE recursing (to detect cycles)
+          visitedPaths.add(resolvedPath);
+
+          // Strip server-only and mock server-only packages, then recursively process imports
+          let transitiveContent = stripServerOnlyImport(importFile.content);
+          transitiveContent = applyServerOnlyMocks(transitiveContent);
+          debugLog(
+            `processTransitiveImportsRecursively depth=${depth} for ${importFile.path}`,
+          );
+          debugLog(
+            `Calling processTransitiveImportsRecursively depth=${depth + 1} for ${importFile.path}`,
+          );
+          transitiveContent = await withTimeout(
+            `processTransitiveImportsRecursively depth=${depth} for ${path.basename(importFile.path)}`,
+            processTransitiveImportsRecursively(
+              transitiveContent,
+              importFile.path,
+              transitiveFilePath,
+              visitedPaths,
+              depth + 1,
+              startTime, // 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;
+  }
+
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: before remaining imports ${Date.now() - postLoopStartTime}ms`,
+  );
+
+  // Process remaining internal imports that weren't in importedExports
+  // This handles transitive dependencies: when the file content includes code (e.g., from
+  // other functions in the same file) that imports from files with "server-only"
+  debugLog('Extracting remaining import paths');
+  const remainingImportPaths = extractInternalImportPaths(fileContent);
+  debugLog('Found remaining import paths', {
+    count: remainingImportPaths.length,
+  });
+
+  // Get all file paths that are in importedExports - these are handled by main processing
+  const importedExportFilePaths = new Set(
+    allImportedExports.map((ie) => ie.resolvedFilePath || ie.filePath),
+  );
+
+  debugLog('Starting remaining imports loop', {
+    remainingCount: remainingImportPaths.length,
+    importedExportCount: importedExportFilePaths.size,
+  });
+
+  let remainingImportIndex = 0;
+  debugLog(
+    `[REMAINING] Starting remaining imports loop, ${remainingImportPaths.length} imports`,
+  );
+  for (const importPath of remainingImportPaths) {
+    remainingImportIndex++;
+    debugLog(
+      `[REMAINING LOOP] import ${remainingImportIndex}/${remainingImportPaths.length}: ${importPath}`,
+    );
+
+    // Skip imports that point to generated CodeYam files (same skip logic as
+    // rewriteRelativeModuleImports). Without this, MockData files from earlier
+    // captures that get discovered by the TypeScript compiler would be treated as
+    // regular imports, creating transitive copies with stale content.
+    const scenarioFilePattern = /[a-f0-9]{64}_\w+_[A-Z]\w*$/;
+    const mockDataPattern = /__codeyamMocks__\//;
+    if (
+      scenarioFilePattern.test(importPath) ||
+      mockDataPattern.test(importPath)
+    ) {
+      continue;
+    }
+
+    // Resolve the import path to a project file path
+    const resolvedFilePath = resolveImportPath(importPath, file.path, project);
+
+    if (!resolvedFilePath) {
+      // Can't resolve - might be a path we don't handle, skip it
+      continue;
+    }
+
+    // Find the file in project.files, using fileStore for O(1) lookup when available
+    // We need to find the file BEFORE checking importedExports to see if it has server-only
+    let targetFile = fileStore
+      ? fileStore.getByPath(resolvedFilePath)
+      : project.files?.find((f) => f.path === resolvedFilePath);
+
+    // Skip if this import is in importedExports - it's handled by the main processing loop
+    // UNLESS the file contains "server-only", in which case we still need a transitive copy
+    // with server-only stripped (even if some exports from the file are mocked).
+    if (importedExportFilePaths.has(resolvedFilePath)) {
+      // Check if the file has server-only before skipping
+      let fileContent = targetFile?.content;
+      if (!fileContent && targetFile && fileStore) {
+        // Load content to check for server-only
+        const loadedFile = await fileStore.ensureContent(resolvedFilePath);
+        fileContent = loadedFile?.content;
+        if (loadedFile) {
+          targetFile = loadedFile;
+        }
+      }
+
+      const hasServerOnly =
+        fileContent && /import\s+["']server-only["']/.test(fileContent);
+
+      if (!hasServerOnly) {
+        continue;
+      }
+      // File has server-only - continue processing to create transitive copy
+    }
+    if (!targetFile) {
+      continue;
+    }
+
+    // Compute the transformed file path (needed for import rewriting even if already processed)
+    const targetFileBasePath = safeFolder(
+      targetFile.path.split('/').slice(0, -1).join('/'),
+    );
+    const targetFileExtension = targetFile.name.split('.').pop();
+    const targetFileIsIndex = isIndexPath(targetFile.path);
+    // Limit path hash length to prevent ENAMETOOLONG errors
+    const filePathHash = safeFileName(targetFile.path, { maxLength: 80 });
+    const targetScenarioSlug = safeFileName(scenario.name, { maxLength: 60 });
+    const transformedFilePath = `${PROJECT_RELATIVE_PATH}/${targetFileBasePath}/${filePathHash}_${targetFileIsIndex ? 'index_' : ''}transitive_${targetScenarioSlug}.${targetFileExtension}`;
+
+    // Check if we've already processed this file as a transitive copy
+    // Note: __data_file_written__ is for entity-specific scenario files with different naming,
+    // but we still need transitive copies for server-only stripping. Data entity files may
+    // only export specific items, so we need a full transitive copy with all exports.
+    const alreadyTransitive = writtenScenarioComponents[
+      resolvedFilePath
+    ]?.includes('__transitive_file_written__');
+
+    if (!alreadyTransitive) {
+      // Ensure content is loaded (LazyFileStore loads content on-demand)
+      if (!targetFile.content && fileStore) {
+        targetFile = await fileStore.ensureContent(resolvedFilePath);
+      }
+      if (!targetFile?.content) {
+        continue;
+      }
+
+      // Get the file content and apply transformations
+      let transformedContent = targetFile.content;
+      transformedContent = stripServerOnlyImport(transformedContent);
+      transformedContent = applyServerOnlyMocks(transformedContent);
+
+      // Recursively process this transitive file's imports
+      // This handles the nested case: service.ts → brevo.ts → constants.ts
+      const nestedImportPaths = extractInternalImportPaths(transformedContent);
+      debugLog(
+        `[NESTED] Processing ${nestedImportPaths.length} nested imports for ${targetFile.path}`,
+      );
+      let nestedIndex = 0;
+      for (const nestedImportPath of nestedImportPaths) {
+        nestedIndex++;
+        debugLog(
+          `[NESTED LOOP] import ${nestedIndex}/${nestedImportPaths.length}: ${nestedImportPath}`,
+        );
+        const nestedResolvedPath = resolveImportPath(
+          nestedImportPath,
+          targetFile.path,
+          project,
+        );
+        if (!nestedResolvedPath) continue;
+
+        // Get file info for building the transformed path
+        let nestedFile = fileStore
+          ? fileStore.getByPath(nestedResolvedPath)
+          : project.files?.find((f) => f.path === nestedResolvedPath);
+        if (!nestedFile) continue;
+
+        // Build the transformed path (needed for import rewriting even if already processed)
+        const nestedBasePath = safeFolder(
+          nestedFile.path.split('/').slice(0, -1).join('/'),
+        );
+        const nestedExtension = nestedFile.name.split('.').pop();
+        const nestedIsIndex = isIndexPath(nestedFile.path);
+        // Limit path hash length to prevent ENAMETOOLONG errors
+        const nestedPathHash = safeFileName(nestedFile.path, { maxLength: 80 });
+        const nestedScenarioSlug = safeFileName(scenario.name, {
+          maxLength: 60,
+        });
+        const nestedTransformedPath = `${PROJECT_RELATIVE_PATH}/${nestedBasePath}/${nestedPathHash}_${nestedIsIndex ? 'index_' : ''}transitive_${nestedScenarioSlug}.${nestedExtension}`;
+
+        // Check if already processed as a transitive file (we can rewrite to point to it)
+        // Note: __data_file_written__ is for entity-specific scenario files with different naming,
+        // but we still need transitive copies for server-only stripping in the import chain
+        const nestedAlreadyTransitive = writtenScenarioComponents[
+          nestedResolvedPath
+        ]?.includes('__transitive_file_written__');
+
+        if (!nestedAlreadyTransitive) {
+          // Ensure content is loaded for nested files
+          if (!nestedFile.content && fileStore) {
+            nestedFile = await fileStore.ensureContent(nestedResolvedPath);
+          }
+          if (!nestedFile?.content) continue;
+
+          // Strip server-only, mock server-only packages, and recursively process imports
+          // This handles chains of any depth: A -> B -> C -> D
+          let nestedContent = stripServerOnlyImport(nestedFile.content);
+          nestedContent = applyServerOnlyMocks(nestedContent);
+          debugLog(
+            `processTransitiveImportsRecursively (nested) for ${nestedFile.path}`,
+          );
+          nestedContent = await withTimeout(
+            `processTransitiveImportsRecursively (nested) for ${path.basename(nestedFile.path)}`,
+            processTransitiveImportsRecursively(
+              nestedContent,
+              nestedFile.path,
+              nestedTransformedPath,
+            ),
+            30000, // 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`);
+  }
+
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: remaining imports loop took ${Date.now() - postLoopStartTime}ms`,
   );
 
   const scenarioComponentComment = `// This file is auto-generated by CodeYam. Do not edit this file manually.
@@ -1810,28 +2998,103 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
 // Scenario: ${scenario.id} - ${scenario.name}
 `;
 
+  // Final pass: Rename any namespace imports (import * as X from '...') that have
+  // corresponding mock code using ...X__cyOriginal spread pattern.
+  // This handles cases where:
+  // 1. The import path was rewritten by transitive import handling
+  // 2. The import wasn't caught by the earlier renaming logic
+  // We scan for all __cyOriginal references in the mock code and ensure the imports are renamed.
+  const cyOriginalReferences = fileContent.match(/\.\.\.(\w+)__cyOriginal/g);
+  if (cyOriginalReferences) {
+    const uniqueNames = [
+      ...new Set(
+        cyOriginalReferences.map((ref) =>
+          ref.replace('...', '').replace('__cyOriginal', ''),
+        ),
+      ),
+    ];
+    for (const name of uniqueNames) {
+      // Match namespace imports for this name that haven't been renamed yet
+      const namespaceImportRegex = new RegExp(
+        `(import\\s+\\*\\s+as\\s+)${escapeRegExp(name)}(\\s+from\\s+['"][^'"]*['"])`,
+        'g',
+      );
+      fileContent = fileContent.replace(
+        namespaceImportRegex,
+        `$1${name}__cyOriginal$2`,
+      );
+    }
+  }
+
+  // For route components (page.tsx, layout.tsx), the component IS the Next.js page.
+  // There's no wrapper page to inject argumentsData as props (unlike non-route components
+  // which get a scenarioComponent wrapper). We need to wrap the default export so that
+  // the scenario's argumentsData is passed as props to the component.
+  if (
+    isFrameworkRoute(file, entity, framework, file === rootFile) &&
+    rootAnalysis.metadata?.scenariosDataStructure?.arguments?.length > 0
+  ) {
+    const positionalArguments =
+      rootAnalysis.metadata.scenariosDataStructure.arguments;
+    const hasNamedArgs =
+      positionalArguments.length === 1 &&
+      typeof positionalArguments[0] === 'object';
+
+    if (hasNamedArgs) {
+      // Match: export default function Name(
+      // Also: export default async function Name(
+      const defaultExportMatch = fileContent.match(
+        /export\s+default\s+(async\s+)?function\s+(\w+)\s*\(/,
+      );
+
+      if (defaultExportMatch) {
+        const funcName = defaultExportMatch[2];
+
+        // Remove "export default" from the original function declaration
+        fileContent = fileContent.replace(
+          /export\s+default\s+(async\s+)?function\s+(\w+)\s*\(/,
+          '$1function $2(',
+        );
+
+        // Ensure scenarios import is present
+        const mockDataPath = `${relativeMocksDir}/MockData_${safeFileName(scenario.name)}`;
+        if (fileContent.indexOf('import { scenarios } from') === -1) {
+          fileContent = `import { scenarios } from "${mockDataPath}";\n\n${fileContent}`;
+        }
+
+        // Add wrapper default export that injects argumentsData as props
+        fileContent += `\n\nexport default function _CYRouteWrapper(props: any) {
+  const _cyArgs = scenarios().data()?.['arguments']?.[0] ?? {};
+  return <${funcName} {...props} {..._cyArgs} />;
+}\n`;
+      }
+    }
+  }
+
   // Use the directive that was extracted at the beginning of processing
   // This ensures it stays at the very top even after imports are prepended
+  // NOTE: We only preserve "use client" directives, NOT "use server" directives.
+  // Server action files get mocked with objects that aren't async functions,
+  // which would violate Next.js's "use server" requirement:
+  // "A 'use server' file can only export async functions, found object."
   let finalContent: string;
-  if (extractedDirective) {
+  if (extractedDirective && extractedDirective.includes('client')) {
     finalContent = `${extractedDirective}\n\n${scenarioComponentComment}\n\n${fileContent}`;
-    console.log(
-      `CodeYam: Placed "${extractedDirective}" directive at top of file: ${scenarioComponentPath}`,
-    );
   } else {
     finalContent = `${scenarioComponentComment}\n\n${fileContent}`;
   }
 
+  debugLog('About to write final scenario file', {
+    scenarioComponentPath,
+    contentLength: finalContent.length,
+  });
   await writeFile(scenarioComponentPath, finalContent);
+  debugLog('Successfully wrote scenario file');
   scenarioComponentPaths.push(scenarioComponentPath);
 
-  console.log('CodeYam [writeScenarioComponents]: Generated scenario files', {
-    entityName: entity.name,
-    filePath: file.path,
-    scenarioName: scenario.name,
-    scenarioComponentPathsGenerated: scenarioComponentPaths,
-    writtenScenarioComponentKeys: Object.keys(writtenScenarioComponents),
-  });
+  console.log(
+    `[WriteScenario] POST-LOOP ${entity.name}: COMPLETE total=${Date.now() - postLoopStartTime}ms`,
+  );
 
   return { scenarioComponentPaths, writtenScenarioComponents };
 }