@codeyam/codeyam-cli 0.1.0-bleeding-edge.8afd3ee → 0.1.0-staging.036391e

package/analyzer-template/packages/ai/src/lib/generateEntityScenarioData.ts

@@ -1,9 +1,13 @@
 import completionCall from './completionCall';
 import generateEntityScenarioDataGenerator from './promptGenerators/generateEntityScenarioDataGenerator';
+import generateMissingKeysPrompt from './promptGenerators/generateMissingKeysPrompt';
+import generateChunkPrompt from './promptGenerators/generateChunkPrompt';
 import { saveLlmCall } from '~codeyam/aws/dynamodb';
+import { trackDataSnapshot } from './e2eDataTracking';
 import type {
   Analysis,
   Entity,
+  ExecutionFlow,
   Scenario,
   ScenarioData,
   ScenariosDataStructure,
@@ -11,15 +15,646 @@ import type {
 import validateJson from './validateJson';
 import { awsLog, awsLogDebugLevel } from '~codeyam/utils';
 import { AI, parseJsonSafe } from '~codeyam/ai';
+import convertNullToUndefinedBySchema from './dataStructure/helpers/convertNullToUndefinedBySchema';
+import convertTypeAnnotationsToValues from './dataStructure/helpers/convertTypeAnnotationsToValues';
+import fixNullIdsBySchema from './dataStructure/helpers/fixNullIdsBySchema';
+import coerceObjectsToPrimitivesBySchema from './dataStructure/helpers/coerceObjectsToPrimitivesBySchema';
+import { JsonTypeDefinition } from '~codeyam/types';
+import { deepMerge } from '~codeyam/generate';
+import {
+  chunkDataStructure,
+  getRequiredValuesForChunk,
+} from './dataStructureChunking';
+
+/**
+ * Check if any of the scenario's covered flows require error data.
+ * Returns true if any requiredValue has an error path with truthy comparison.
+ */
+function scenarioRequiresErrorData(
+  scenario: Scenario,
+  executionFlows: ExecutionFlow[] | undefined,
+): boolean {
+  const coveredFlowIds = scenario.metadata?.coveredFlows || [];
+  for (const flowId of coveredFlowIds) {
+    const flow = executionFlows?.find((f) => f.id === flowId);
+    if (!flow?.requiredValues) continue;
+    for (const rv of flow.requiredValues) {
+      // Check if any requiredValue has an error path and requires it to be truthy
+      if (
+        rv.attributePath?.toLowerCase().includes('.error') &&
+        rv.comparison === 'truthy'
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Deep merge scenario data with default scenario data.
+ * The scenario-specific data takes precedence, with default filling in missing fields.
+ *
+ * IMPORTANT: null values are PRESERVED (not removed) in the result.
+ * This is critical because writeMockDataTsx.ts does another deepMerge with default data,
+ * and it needs null values to prevent defaults from being filled back in.
+ * If we removed null here, the second merge would restore the defaults,
+ * making scenarios identical to the default scenario.
+ */
+function deepMergeScenarioData(
+  defaultData: Record<string, any>,
+  scenarioData: Record<string, any>,
+): Record<string, any> {
+  // Guard against non-object inputs (LLM sometimes returns primitives)
+  if (
+    typeof scenarioData !== 'object' ||
+    scenarioData === null ||
+    Array.isArray(scenarioData)
+  ) {
+    // Return scenario value directly if it's not a mergeable object
+    return scenarioData;
+  }
+  if (
+    typeof defaultData !== 'object' ||
+    defaultData === null ||
+    Array.isArray(defaultData)
+  ) {
+    // Return scenario value if default isn't mergeable
+    return scenarioData;
+  }
+
+  const result: Record<string, any> = {};
+
+  // Start with all keys from default
+  for (const key of Object.keys(defaultData)) {
+    if (key in scenarioData) {
+      const scenarioValue = scenarioData[key];
+      const defaultValue = defaultData[key];
+
+      // null means explicitly override with null (falsy value)
+      // IMPORTANT: We preserve null instead of removing the key
+      // This ensures writeMockDataTsx's deepMerge won't fill in defaults
+      if (scenarioValue === null) {
+        result[key] = null;
+        continue;
+      }
+
+      // Deep merge objects (but not arrays)
+      if (
+        typeof scenarioValue === 'object' &&
+        !Array.isArray(scenarioValue) &&
+        typeof defaultValue === 'object' &&
+        !Array.isArray(defaultValue) &&
+        defaultValue !== null
+      ) {
+        result[key] = deepMergeScenarioData(defaultValue, scenarioValue);
+      } else {
+        // Use scenario value (overrides default)
+        result[key] = scenarioValue;
+      }
+    } else {
+      // Key not in scenario, use default
+      result[key] = defaultData[key];
+    }
+  }
+
+  // Add any keys that are only in scenario data (including null values)
+  for (const key of Object.keys(scenarioData)) {
+    if (!(key in defaultData)) {
+      result[key] = scenarioData[key];
+    }
+  }
+
+  return result;
+}
 
 const DEFAULT_SCENARIO_NAME = 'Default Scenario';
 
+/**
+ * Find the path to a key within a nested dataForMocks structure.
+ * Returns the path as an array of keys, or null if not found.
+ *
+ * @example
+ * // dataForMocks = { trpc: { fastener: { "useMutation()": { isLoading: "boolean" } } } }
+ * // findKeyPath("fastener", dataForMocks) returns ["trpc"]
+ */
+function findKeyPath(
+  targetKey: string,
+  obj: JsonTypeDefinition,
+  currentPath: string[] = [],
+): string[] | null {
+  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+    return null;
+  }
+
+  for (const key of Object.keys(obj)) {
+    if (key === targetKey) {
+      return currentPath;
+    }
+
+    // Recursively search in nested objects
+    const nested = obj[key];
+    if (
+      typeof nested === 'object' &&
+      nested !== null &&
+      !Array.isArray(nested)
+    ) {
+      const result = findKeyPath(targetKey, nested as JsonTypeDefinition, [
+        ...currentPath,
+        key,
+      ]);
+      if (result !== null) {
+        return result;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Relocate misplaced nested keys in mockData to their correct position
+ * based on the dataForMocks structure.
+ *
+ * When the LLM returns mockData with keys at the wrong nesting level
+ * (e.g., { trpc: { quote: {...} }, fastener: {...} } when fastener should
+ * be inside trpc), this function moves them to the correct position.
+ *
+ * This function works recursively to handle nested misplacements, not just
+ * root-level ones. For example, if getQuote is at trpc.getQuote instead of
+ * trpc.quote.getQuote, it will be relocated.
+ *
+ * @example
+ * // dataForMocks: { trpc: { quote: {...}, fastener: {...} } }
+ * // mockData: { trpc: { quote: {...} }, fastener: {...} }
+ * // After: mockData: { trpc: { quote: {...}, fastener: {...} } }
+ *
+ * @example (nested case)
+ * // dataForMocks: { trpc: { quote: { getQuote: {...} } } }
+ * // mockData: { trpc: { quote: {...}, getQuote: {...} } }
+ * // After: mockData: { trpc: { quote: { getQuote: {...} } } }
+ */
+function relocateMisplacedNestedKeys(
+  mockData: Record<string, unknown>,
+  dataForMocks: JsonTypeDefinition,
+  currentPathForLogging: string[] = [],
+): void {
+  if (typeof dataForMocks !== 'object' || dataForMocks === null) {
+    return;
+  }
+
+  const keysInSchema = Object.keys(dataForMocks);
+  const keysToRelocate: { key: string; path: string[] }[] = [];
+
+  // Find keys in mockData that are NOT at this level in dataForMocks
+  // but DO exist somewhere nested in dataForMocks
+  for (const key of Object.keys(mockData)) {
+    if (!keysInSchema.includes(key)) {
+      // This key is at this level in mockData but not at this level in dataForMocks
+      // Check if it exists somewhere nested in dataForMocks
+      const path = findKeyPath(key, dataForMocks);
+      if (path !== null && path.length > 0) {
+        keysToRelocate.push({ key, path });
+      }
+    }
+  }
+
+  // Relocate each misplaced key to its correct nested position
+  for (const { key, path } of keysToRelocate) {
+    const value = mockData[key];
+
+    // Navigate to the correct parent in mockData, creating nested objects if needed
+    let current: Record<string, unknown> = mockData;
+    for (const pathKey of path) {
+      if (current[pathKey] === undefined) {
+        current[pathKey] = {};
+      }
+      current = current[pathKey] as Record<string, unknown>;
+    }
+
+    // Deep merge the value into the correct location
+    // Use deep merge to preserve existing data at that location
+    if (current[key] !== undefined && typeof current[key] === 'object') {
+      current[key] = deepMerge(
+        current[key] as Record<string, unknown>,
+        value as Record<string, unknown>,
+      );
+    } else {
+      current[key] = value;
+    }
+
+    // Remove the key from its current (wrong) level
+    delete mockData[key];
+
+    const fullPath = [...currentPathForLogging, ...path].join('.');
+    awsLog(
+      `CodeYam: Relocated misplaced key "${key}" from [${currentPathForLogging.join('.')}] to [${fullPath}]`,
+    );
+  }
+
+  // Recursively process nested objects to handle deeply nested misplacements
+  for (const key of Object.keys(mockData)) {
+    const mockValue = mockData[key];
+    const schemaValue = dataForMocks[key];
+
+    // Only recurse if both mockData and schema have nested objects at this key
+    if (
+      typeof mockValue === 'object' &&
+      mockValue !== null &&
+      !Array.isArray(mockValue) &&
+      typeof schemaValue === 'object' &&
+      schemaValue !== null &&
+      !Array.isArray(schemaValue)
+    ) {
+      relocateMisplacedNestedKeys(
+        mockValue as Record<string, unknown>,
+        schemaValue as JsonTypeDefinition,
+        [...currentPathForLogging, key],
+      );
+    }
+  }
+}
+
+/**
+ * Generate default mock data for a schema type.
+ * Returns reasonable default values based on the schema type string.
+ */
+function generateDefaultForSchemaType(schemaType: unknown): unknown {
+  if (typeof schemaType === 'string') {
+    // Handle common type strings
+    if (schemaType === 'function') return () => {};
+    if (schemaType === 'promise') return Promise.resolve();
+    if (schemaType === 'boolean') return false;
+    if (schemaType === 'string') return '';
+    if (schemaType === 'number') return 0;
+    if (schemaType.includes('number | undefined')) return undefined;
+    if (schemaType.includes('string | undefined')) return undefined;
+    if (schemaType.includes('boolean | undefined')) return undefined;
+    if (schemaType.includes('| undefined')) return undefined;
+    if (schemaType.includes('| null')) return null;
+    return schemaType; // Return the type as a string placeholder
+  }
+  if (
+    typeof schemaType === 'object' &&
+    schemaType !== null &&
+    !Array.isArray(schemaType)
+  ) {
+    // Recursively generate defaults for nested objects
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(schemaType)) {
+      result[key] = generateDefaultForSchemaType(value);
+    }
+    return result;
+  }
+  return undefined;
+}
+
+/**
+ * Detect if a string should be converted to an array.
+ * Returns the array if the field appears to be an array field, or null if it should remain a string.
+ *
+ * This handles two cases:
+ * 1. Comma-separated values: "color,size" -> ["color", "size"]
+ * 2. Single values for array-named fields: "Finish" -> ["Finish"]
+ */
+function parseCommaSeparatedStringAsArray(
+  value: string,
+  key: string,
+): string[] | null {
+  // Heuristic: if the key name suggests it's an array field, convert it
+  // Common patterns: *_attributes, *_ids, *_items, *_tags, *_values, plural names
+  // Check this FIRST because array-named fields should be converted regardless
+  // of whether they contain commas (single values become single-element arrays).
+  const arrayFieldPatterns = [
+    /_attributes$/i,
+    /_ids$/i,
+    /_items$/i,
+    /_tags$/i,
+    /_values$/i,
+    /_types$/i,
+    /_names$/i,
+    /_keys$/i,
+    /^attributes$/i,
+    /^items$/i,
+    /^tags$/i,
+    /^values$/i,
+  ];
+
+  const looksLikeArrayField = arrayFieldPatterns.some((pattern) =>
+    pattern.test(key),
+  );
+
+  if (looksLikeArrayField) {
+    // Skip newlines check - multiline values shouldn't be split
+    if (value.includes('\n')) {
+      return null;
+    }
+    // Split by comma and trim whitespace
+    const parts = value.split(',').map((s) => s.trim());
+    // Filter out empty strings - this handles both "Finish" -> ["Finish"]
+    // and "" -> []
+    return parts.filter((s) => s.length > 0);
+  }
+
+  // For non-array-named fields, only convert if there are commas
+  if (!value.includes(',')) {
+    return null;
+  }
+
+  // For non-array-named fields, apply stricter sentence detection
+  // Skip if it looks like a sentence (comma followed by space and lowercase)
+  if (/,\s+[a-z]/.test(value)) {
+    return null;
+  }
+  // Skip if it contains newlines (likely formatted text)
+  if (value.includes('\n')) {
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Convert comma-separated string values to arrays when they look like array data.
+ * This handles cases where the LLM generates strings like "color,size" instead
+ * of arrays like ["color", "size"] due to schema type misdetection.
+ */
+function convertCommaSeparatedStringsToArrays(
+  mockData: Record<string, unknown>,
+): void {
+  for (const [key, value] of Object.entries(mockData)) {
+    if (typeof value === 'string') {
+      const asArray = parseCommaSeparatedStringAsArray(value, key);
+      if (asArray !== null) {
+        mockData[key] = asArray;
+        awsLog(
+          `CodeYam: Converted comma-separated string to array for key "${key}": "${value}" -> [${asArray.map((s) => `"${s}"`).join(', ')}]`,
+        );
+      }
+    } else if (
+      value !== null &&
+      typeof value === 'object' &&
+      !Array.isArray(value)
+    ) {
+      // Recursively process nested objects
+      convertCommaSeparatedStringsToArrays(value as Record<string, unknown>);
+    } else if (Array.isArray(value)) {
+      // Recursively process arrays (each element could be an object)
+      for (const item of value) {
+        if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+          convertCommaSeparatedStringsToArrays(item as Record<string, unknown>);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Ensure all keys from dataForMocks have corresponding data in mockData.
+ * For missing keys, generate default values based on the schema.
+ * Recursively checks nested objects to fill in any missing nested fields.
+ */
+function fillMissingMockDataKeysWithDefaults(
+  mockData: Record<string, unknown>,
+  dataForMocks: JsonTypeDefinition,
+  pathPrefix: string = '',
+): void {
+  if (typeof dataForMocks !== 'object' || dataForMocks === null) {
+    return;
+  }
+
+  const missingKeys: string[] = [];
+
+  for (const key of Object.keys(dataForMocks)) {
+    const fullPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+
+    if (mockData[key] === undefined) {
+      missingKeys.push(fullPath);
+      // Generate default data based on schema
+      const schemaForKey = dataForMocks[key];
+      mockData[key] = generateDefaultForSchemaType(schemaForKey);
+    } else {
+      // Key exists, but if both are objects, recursively check for missing nested keys
+      const schemaValue = dataForMocks[key];
+      const mockValue = mockData[key];
+      if (
+        typeof schemaValue === 'object' &&
+        schemaValue !== null &&
+        !Array.isArray(schemaValue) &&
+        typeof mockValue === 'object' &&
+        mockValue !== null &&
+        !Array.isArray(mockValue)
+      ) {
+        fillMissingMockDataKeysWithDefaults(
+          mockValue as Record<string, unknown>,
+          schemaValue as JsonTypeDefinition,
+          fullPath,
+        );
+      }
+    }
+  }
+
+  if (missingKeys.length > 0) {
+    awsLog(
+      `CodeYam: Generated default mock data for ${missingKeys.length} missing key(s): ${missingKeys.slice(0, 10).join(', ')}${missingKeys.length > 10 ? '...' : ''}`,
+    );
+  }
+}
+
+/**
+ * Enforce execution flow requiredValues by setting falsy paths to null.
+ *
+ * The LLM doesn't reliably generate null for `comparison: 'falsy'` requirements.
+ * For example, a flow like "diffView: falsy" should hide a modal, but the LLM
+ * might generate a truthy object, causing the modal to show in all screenshots.
+ *
+ * This function:
+ * 1. Gets requiredValues from covered flows
+ * 2. For 'falsy' comparisons: sets the value to null
+ * 3. For 'truthy' comparisons with falsy values: generates a default truthy value
+ */
+function enforceRequiredValues(
+  mockData: Record<string, unknown>,
+  coveredFlowIds: string[],
+  executionFlows: ExecutionFlow[],
+): void {
+  if (!coveredFlowIds.length || !executionFlows.length) {
+    return;
+  }
+
+  // Get all requiredValues from covered flows
+  const coveredFlows = executionFlows.filter((flow) =>
+    coveredFlowIds.includes(flow.id),
+  );
+
+  for (const flow of coveredFlows) {
+    if (!flow.requiredValues) continue;
+
+    for (const rv of flow.requiredValues) {
+      if (!rv.attributePath) continue;
+
+      // Find the value in mockData - the path could be nested
+      // e.g., attributePath: "diffView" could be at mockData['useDiffModal()'].diffView
+      const result = findAndSetValueInMockData(
+        mockData,
+        rv.attributePath,
+        rv.comparison,
+        rv.valueType,
+      );
+
+      if (result.found) {
+        awsLog(
+          `CodeYam: Enforced ${rv.comparison} for ${rv.attributePath} (set to ${result.newValue === null ? 'null' : typeof result.newValue})`,
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Find a value in mockData by attributePath and enforce the comparison.
+ * The attributePath could be a simple key or a nested path.
+ *
+ * Returns { found: boolean, newValue: unknown }
+ */
+function findAndSetValueInMockData(
+  mockData: Record<string, unknown>,
+  attributePath: string,
+  comparison: string,
+  valueType?: string,
+): { found: boolean; newValue?: unknown } {
+  // Try to find the path at various nesting levels
+  // The attributePath might be "diffView" but the actual location is
+  // mockData['useDiffModal()'].diffView
+
+  // Strategy 1: Direct path (e.g., mockData[attributePath])
+  if (attributePath in mockData) {
+    const currentValue = mockData[attributePath];
+    const { shouldChange, newValue } = getEnforcedValue(
+      currentValue,
+      comparison,
+      valueType,
+    );
+    if (shouldChange) {
+      mockData[attributePath] = newValue;
+      return { found: true, newValue };
+    }
+    return { found: true, newValue: currentValue };
+  }
+
+  // Strategy 2: Search in nested objects
+  for (const [key, value] of Object.entries(mockData)) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      const nestedObj = value as Record<string, unknown>;
+
+      // Check if attributePath exists in this nested object
+      if (attributePath in nestedObj) {
+        const currentValue = nestedObj[attributePath];
+        const { shouldChange, newValue } = getEnforcedValue(
+          currentValue,
+          comparison,
+          valueType,
+        );
+        if (shouldChange) {
+          nestedObj[attributePath] = newValue;
+          return { found: true, newValue };
+        }
+        return { found: true, newValue: currentValue };
+      }
+
+      // Also check dot-notation paths (e.g., "diffView.type")
+      if (attributePath.includes('.')) {
+        const parts = attributePath.split('.');
+        const firstPart = parts[0];
+        if (firstPart in nestedObj) {
+          // Recurse with the rest of the path
+          const result = findAndSetValueInMockData(
+            nestedObj,
+            attributePath,
+            comparison,
+            valueType,
+          );
+          if (result.found) return result;
+        }
+      }
+
+      // Recursively search deeper
+      const result = findAndSetValueInMockData(
+        nestedObj,
+        attributePath,
+        comparison,
+        valueType,
+      );
+      if (result.found) return result;
+    }
+  }
+
+  return { found: false };
+}
+
+/**
+ * Determine if a value should be changed to match a comparison requirement.
+ *
+ * For 'falsy' comparison: truthy values should become null
+ * For 'truthy' comparison: falsy values should become a default truthy value
+ */
+function getEnforcedValue(
+  currentValue: unknown,
+  comparison: string,
+  valueType?: string,
+): { shouldChange: boolean; newValue: unknown } {
+  const isTruthy = Boolean(currentValue);
+
+  if (comparison === 'falsy') {
+    // Value should be falsy
+    if (isTruthy) {
+      return { shouldChange: true, newValue: null };
+    }
+    return { shouldChange: false, newValue: currentValue };
+  }
+
+  if (comparison === 'truthy') {
+    // Value should be truthy
+    if (!isTruthy) {
+      // Generate a default truthy value based on valueType
+      const defaultValue = generateDefaultTruthyValue(valueType);
+      return { shouldChange: true, newValue: defaultValue };
+    }
+    return { shouldChange: false, newValue: currentValue };
+  }
+
+  // For other comparisons (equals, exists, etc.), don't auto-enforce
+  return { shouldChange: false, newValue: currentValue };
+}
+
+/**
+ * Generate a default truthy value for a given type.
+ */
+function generateDefaultTruthyValue(valueType?: string): unknown {
+  if (!valueType) return { _placeholder: true };
+
+  switch (valueType.toLowerCase()) {
+    case 'string':
+      return 'default-value';
+    case 'number':
+      return 1;
+    case 'boolean':
+      return true;
+    case 'array':
+      return [{ _placeholder: true }];
+    case 'object':
+    default:
+      return { _placeholder: true };
+  }
+}
+
 type ScenarioDataWithoutDescription = Omit<ScenarioData, 'scenarioDescription'>;
 
 interface GenerateEntityScenarioDataArgs {
   entity: Pick<Entity, 'name' | 'filePath' | 'metadata'>;
   structure: ScenariosDataStructure;
   scenarios: Scenario[];
+  executionFlows?: ExecutionFlow[];
   incompleteResponse?: string;
   analysis: Analysis;
   model?: AI.Model;
@@ -33,10 +668,96 @@ type GenerateDataForScenarioArgs = Omit<
   defaultScenarioData?: ScenarioData;
 };
 
+interface FillMissingMockDataKeysArgs {
+  structure: ScenariosDataStructure;
+  scenario: Scenario;
+  executionFlows: ExecutionFlow[] | undefined;
+  fullScenarioData: ScenarioData;
+  model: AI.Model | undefined;
+}
+
+/**
+ * For Default Scenario only: detect missing mockData keys and make a follow-up
+ * LLM call to fill them in. This handles cases where the LLM completes normally
+ * but misses some keys (often small/simple ones when the schema is large).
+ */
+async function fillMissingMockDataKeys({
+  structure,
+  scenario,
+  executionFlows,
+  fullScenarioData,
+  model,
+}: FillMissingMockDataKeysArgs): Promise<void> {
+  if (
+    !structure.dataForMocks ||
+    typeof structure.dataForMocks !== 'object' ||
+    Array.isArray(structure.dataForMocks)
+  ) {
+    return;
+  }
+
+  const expectedKeys = Object.keys(structure.dataForMocks);
+  const generatedKeys = Object.keys(fullScenarioData.data.mockData || {});
+  const missingKeys = expectedKeys.filter((k) => !generatedKeys.includes(k));
+
+  if (missingKeys.length === 0) {
+    return;
+  }
+
+  awsLog(
+    `Default Scenario missing ${missingKeys.length} keys, making follow-up call`,
+    { missingKeys },
+  );
+
+  // Build subset schema with only missing keys
+  const missingSchema: Record<string, any> = {};
+  for (const key of missingKeys) {
+    missingSchema[key] = (structure.dataForMocks as Record<string, any>)[key];
+  }
+
+  const followUpPrompt = generateMissingKeysPrompt({
+    scenario,
+    executionFlows,
+    generatedMockData: fullScenarioData.data.mockData || {},
+    missingSchema,
+  });
+
+  const followUpResponse = await completionCall({
+    type: 'generateMissingMockData',
+    systemMessage: generateMissingKeysSystemMessage(),
+    prompt: followUpPrompt,
+    model,
+  });
+
+  if (!followUpResponse.completion) {
+    return;
+  }
+
+  const followUpJson = validateJson(followUpResponse.completion);
+  const followUpParsed = parseJsonSafe(followUpJson);
+
+  if (
+    !followUpParsed ||
+    typeof followUpParsed !== 'object' ||
+    !('mockData' in followUpParsed)
+  ) {
+    return;
+  }
+
+  const followUpMockData = (followUpParsed as any).mockData;
+  if (followUpMockData && typeof followUpMockData === 'object') {
+    fullScenarioData.data.mockData = {
+      ...fullScenarioData.data.mockData,
+      ...followUpMockData,
+    };
+  }
+}
+
 export async function generateDataForScenario({
   entity,
   structure,
   scenario,
+  executionFlows,
   defaultScenarioData,
   incompleteResponse,
   analysis,
@@ -44,11 +765,99 @@ export async function generateDataForScenario({
 }: GenerateDataForScenarioArgs) {
   awsLogDebugLevel(1, `Generating data for ${entity.name}: ${scenario.name}`);
 
+  // Check if we should chunk the data structure for focused processing
+  let chunkedMockData: Record<string, unknown> | undefined;
+  const coveredFlowIds = scenario.metadata?.coveredFlows || [];
+
+  if (
+    structure.dataForMocks &&
+    !incompleteResponse // Don't do chunked calls on continuation
+  ) {
+    const chunks = chunkDataStructure(structure.dataForMocks);
+
+    // If we have multiple chunks, process each one with a focused call
+    if (chunks.length > 1) {
+      awsLog(
+        `Data structure has ${Object.keys(structure.dataForMocks).length} keys, splitting into ${chunks.length} chunks for focused processing`,
+      );
+
+      chunkedMockData = {};
+
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const chunkKeys = Object.keys(chunk || {});
+
+        // Get relevant requiredValues for this chunk
+        const relevantRequiredValues = getRequiredValuesForChunk(
+          chunk,
+          executionFlows || [],
+          coveredFlowIds,
+        );
+
+        awsLog(
+          `Processing chunk ${i + 1}/${chunks.length}: ${chunkKeys.join(', ')}`,
+        );
+
+        const chunkPrompt = generateChunkPrompt({
+          scenario,
+          chunk,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+          relevantRequiredValues,
+        });
+
+        const chunkResponse = await completionCall({
+          type: 'generateChunkMockData',
+          systemMessage: generateChunkSystemMessage(scenario.name),
+          prompt: chunkPrompt,
+          model,
+        });
+
+        // Save chunk call to LLM log for replay support
+        await saveLlmCall({
+          object_type: 'analysis',
+          object_id: analysis.id,
+          propsJson: {
+            entity: { name: entity.name, filePath: entity.filePath },
+            scenario: { name: scenario.name },
+            chunkIndex: i,
+            totalChunks: chunks.length,
+          },
+          ...chunkResponse.stats,
+        });
+
+        if (chunkResponse.completion) {
+          const validJson = validateJson(chunkResponse.completion);
+          const parsed = parseJsonSafe(validJson);
+          if (parsed && typeof parsed === 'object' && 'mockData' in parsed) {
+            const chunkMockData = (parsed as any).mockData;
+            if (chunkMockData && typeof chunkMockData === 'object') {
+              Object.assign(chunkedMockData, chunkMockData);
+              awsLog(
+                `Chunk ${i + 1} generated data for: ${Object.keys(chunkMockData).join(', ')}`,
+              );
+            }
+          }
+        }
+      }
+
+      awsLog(
+        `Chunked processing complete. Generated ${Object.keys(chunkedMockData).length} keys total`,
+      );
+    }
+  }
+
+  // When we have chunked mock data with actual content, tell the main prompt to skip mockData generation
+  // Important: Check for actual keys, not just truthy object, because {} would skip generation incorrectly
+  const hasChunkedData =
+    chunkedMockData && Object.keys(chunkedMockData).length > 0;
   const prompt = generateEntityScenarioDataGenerator(
     structure,
     scenario,
+    executionFlows,
     defaultScenarioData,
     incompleteResponse,
+    { mockDataAlreadyGenerated: hasChunkedData },
   );
 
   const isDefault = scenario.name === DEFAULT_SCENARIO_NAME;
@@ -91,7 +900,7 @@ export async function generateDataForScenario({
     ...response.stats,
   });
 
-  const { completion, finishReason } = response;
+  let { completion, finishReason } = response;
 
   if (!completion) {
     console.log(
@@ -100,42 +909,80 @@ export async function generateDataForScenario({
     return null;
   }
 
-  awsLog(
-    `LLMCall ${llmCall ? llmCall.id : 'N/A'}: ${entity.filePath} ${entity.metadata?.exportAlias ?? entity.name} scenario data completion :>> Finish reason:`,
-    {
-      finishReason,
-      completion,
-    },
+  awsLogDebugLevel(
+    1,
+    `LLMCall ${llmCall ? llmCall.id : 'N/A'}: ${entity.filePath} ${entity.metadata?.exportAlias ?? entity.name} finishReason: ${finishReason}`,
   );
 
+  // If response was truncated due to token limit, make a continuation call
+  if (finishReason === 'length') {
+    awsLogDebugLevel(1, 'Response truncated, making continuation call');
+
+    const continuationResponse = await completionCall({
+      type: 'generateEntityScenarioData',
+      systemMessage: generateIncompleteSystemMessage(scenario.name, isDefault),
+      prompt: completion, // Pass the incomplete response as the prompt
+      model,
+    });
+
+    if (continuationResponse.completion) {
+      completion = completion + continuationResponse.completion;
+      finishReason = continuationResponse.finishReason;
+    }
+  }
+
   const validJson = validateJson(completion);
 
   const parsed = parseJsonSafe(validJson);
   if (!parsed || typeof parsed !== 'object' || !('scenarioData' in parsed)) {
-    console.log('CodeYam Debug: generateDataForScenario failed to parse', {
-      entityName: entity.name,
-      scenarioName: scenario.name,
-      hasParsed: !!parsed,
-      parsedType: typeof parsed,
-      hasScenarioData: parsed && 'scenarioData' in parsed,
-      completionPreview: completion.substring(0, 200),
-    });
+    awsLog(`Failed to parse scenario data for ${entity.name}/${scenario.name}`);
     return null;
   }
 
-  const { scenarioData: scenarioDataWithoutDescription } = parsed as {
+  let { scenarioData: scenarioDataWithoutDescription } = parsed as {
     scenarioData: ScenarioDataWithoutDescription;
   };
 
-  console.log('CodeYam Debug: generateDataForScenario parsed successfully', {
-    entityName: entity.name,
-    scenarioName: scenario.name,
-    parsedScenarioName: scenarioDataWithoutDescription.scenarioName,
-    hasData: !!scenarioDataWithoutDescription.data,
-    dataKeys: scenarioDataWithoutDescription.data
-      ? Object.keys(scenarioDataWithoutDescription.data)
-      : [],
-  });
+  // FIX: LLM sometimes puts mock data keys directly under scenarioData instead of
+  // under scenarioData.data.mockData. Detect and fix this structural issue.
+  if (structure.dataForMocks) {
+    const scenarioDataAsAny = scenarioDataWithoutDescription as any;
+    const reservedKeys = new Set([
+      'scenarioName',
+      'data',
+      'scenarioDescription',
+    ]);
+    const misplacedKeys: string[] = [];
+
+    // Find keys that are directly under scenarioData but should be in mockData
+    for (const key of Object.keys(scenarioDataAsAny)) {
+      if (reservedKeys.has(key)) continue;
+      // If this key exists in the dataForMocks schema, it's misplaced
+      if (key in structure.dataForMocks) {
+        misplacedKeys.push(key);
+      }
+    }
+
+    if (misplacedKeys.length > 0) {
+      // Ensure data.mockData exists
+      if (!scenarioDataAsAny.data) {
+        scenarioDataAsAny.data = {};
+      }
+      if (!scenarioDataAsAny.data.mockData) {
+        scenarioDataAsAny.data.mockData = {};
+      }
+
+      // Move misplaced keys to mockData
+      for (const key of misplacedKeys) {
+        scenarioDataAsAny.data.mockData[key] = scenarioDataAsAny[key];
+        delete scenarioDataAsAny[key];
+      }
+
+      // Update the reference
+      scenarioDataWithoutDescription =
+        scenarioDataAsAny as ScenarioDataWithoutDescription;
+    }
+  }
 
   const fullScenarioData: ScenarioData = {
     ...scenarioDataWithoutDescription,
@@ -144,8 +991,9 @@ export async function generateDataForScenario({
 
   if (structure.dataForMocks && !fullScenarioData.data.argumentsData) {
     fullScenarioData.data.argumentsData = [];
-    if (structure.arguments && !fullScenarioData.data.argumentsData) {
-      fullScenarioData.data.argumentsData = [];
+    // Populate argumentsData from structure.arguments using top-level data values
+    // Bug fix: removed redundant !argumentsData check that was always false after setting to []
+    if (structure.arguments) {
       for (let i = 0; i < structure.arguments.length; ++i) {
         if (!fullScenarioData.data.argumentsData[i]) {
           fullScenarioData.data.argumentsData[i] = {};
@@ -158,14 +1006,158 @@ export async function generateDataForScenario({
     }
   }
 
-  if (structure.dataForMocks && !fullScenarioData.data.mockData) {
-    fullScenarioData.data.mockData = {};
-    for (const propKey of Object.keys(structure.arguments)) {
-      const dataAsAny = fullScenarioData.data as any;
-      fullScenarioData.data.mockData[propKey] = dataAsAny[propKey];
+  // Merge flat-level mock data into mockData.
+  // Sometimes the LLM returns some data inside data.mockData but other data at the flat
+  // data level (e.g., data.useRouter() instead of data.mockData.useRouter()).
+  // This code ensures all dataForMocks keys end up in mockData.
+  if (structure.dataForMocks) {
+    fullScenarioData.data.mockData ||= {};
+    const dataAsAny = fullScenarioData.data as any;
+    for (const propKey of Object.keys(structure.dataForMocks)) {
+      // Only copy if it exists at flat level and not already in mockData
+      if (
+        dataAsAny[propKey] !== undefined &&
+        !fullScenarioData.data.mockData[propKey]
+      ) {
+        fullScenarioData.data.mockData[propKey] = dataAsAny[propKey];
+      }
+    }
+  }
+
+  // Merge chunked mock data from focused calls (takes priority over main call's data)
+  // This ensures keys processed with focused attention are correctly generated.
+  if (chunkedMockData && fullScenarioData.data.mockData) {
+    for (const [key, value] of Object.entries(chunkedMockData)) {
+      // Chunked data takes priority - overwrite main call's potentially wrong data
+      fullScenarioData.data.mockData[key] = value;
+    }
+    awsLog(
+      `Merged chunked mock data for keys: ${Object.keys(chunkedMockData).join(', ')}`,
+    );
+  }
+
+  // Relocate misplaced nested keys to their correct position.
+  // The LLM sometimes places nested keys at root level instead of inside their
+  // parent object (e.g., 'fastener' at root instead of inside 'trpc').
+  // This ensures the mockData structure matches the dataForMocks schema.
+  if (structure.dataForMocks && fullScenarioData.data.mockData) {
+    relocateMisplacedNestedKeys(
+      fullScenarioData.data.mockData,
+      structure.dataForMocks,
+    );
+  }
+
+  // Convert null values to undefined based on schema type constraints.
+  // LLM uses null for "no value" (JSON doesn't support undefined), but TypeScript
+  // types like "string | undefined" don't accept null. This converts null→undefined
+  // for fields typed as "T | undefined" (but preserves null for "T | null").
+  if (structure.dataForMocks && fullScenarioData.data.mockData) {
+    convertNullToUndefinedBySchema(
+      fullScenarioData.data.mockData,
+      structure.dataForMocks,
+    );
+  }
+
+  // Coerce objects/arrays to primitives when the schema expects a primitive type.
+  // The LLM sometimes generates an object where the schema expects "string",
+  // e.g., { body: { "env": "production" } } instead of { body: "some string" }.
+  // This causes runtime errors like "TypeError: body.match is not a function".
+  // Must run BEFORE convertCommaSeparatedStringsToArrays, which intentionally
+  // overrides schema types for array-like field names.
+  if (structure.dataForMocks && fullScenarioData.data.mockData) {
+    coerceObjectsToPrimitivesBySchema(
+      fullScenarioData.data.mockData,
+      structure.dataForMocks,
+    );
+  }
+
+  // Convert comma-separated strings to arrays when appropriate.
+  // The LLM sometimes generates strings like "color,size" instead of arrays
+  // like ["color", "size"] when the schema type is incorrectly inferred as
+  // 'string' instead of 'string[]'. This causes runtime errors when code
+  // calls array methods like .map() on the value.
+  if (fullScenarioData.data.mockData) {
+    convertCommaSeparatedStringsToArrays(fullScenarioData.data.mockData);
+  }
+
+  // Convert type annotation strings that appear as values to actual values.
+  // The LLM sometimes echoes the schema type annotation as the value.
+  // For example, if the schema says { filePath: "string | undefined" },
+  // the LLM might return { filePath: "string | undefined" } instead of
+  // generating an actual value. This converts those type strings to
+  // appropriate default values (e.g., "string | undefined" → undefined).
+  if (fullScenarioData.data.mockData) {
+    convertTypeAnnotationsToValues(fullScenarioData.data.mockData);
+  }
+
+  // Fix null values for ID fields when the schema indicates they should be non-null.
+  // The LLM sometimes generates `null` for ID fields (e.g., `"id": null`) when
+  // the schema type is `"number"`. This causes runtime issues when code checks
+  // `if (!data?.id)` expecting a truthy value.
+  if (structure.dataForMocks && fullScenarioData.data.mockData) {
+    fixNullIdsBySchema(fullScenarioData.data.mockData, structure.dataForMocks);
+  }
+
+  // Enforce execution flow requiredValues by setting falsy paths to null.
+  // The LLM doesn't reliably generate null for falsy requirements (e.g., diffView: falsy
+  // to hide a modal). This post-processing ensures that scenarios match their
+  // covered flows' requiredValues.
+  if (fullScenarioData.data.mockData && executionFlows) {
+    enforceRequiredValues(
+      fullScenarioData.data.mockData,
+      scenario.metadata?.coveredFlows || [],
+      executionFlows,
+    );
+  }
+
+  if (structure.arguments && fullScenarioData.data.argumentsData) {
+    for (let i = 0; i < fullScenarioData.data.argumentsData.length; i++) {
+      if (structure.arguments[i]) {
+        convertNullToUndefinedBySchema(
+          fullScenarioData.data.argumentsData[i],
+          structure.arguments[i],
+        );
+      }
     }
   }
 
+  // For Default Scenario only: check for missing keys and make follow-up call if needed.
+  // This tries to get better-quality data via LLM before falling back to defaults.
+  if (isDefault) {
+    await fillMissingMockDataKeys({
+      structure,
+      scenario,
+      executionFlows,
+      fullScenarioData,
+      model,
+    });
+  }
+
+  // Fill in missing mock data keys with default values (after trying LLM follow-up).
+  // The LLM sometimes doesn't generate data for all keys in large schemas.
+  // This ensures all dataForMocks keys have corresponding data to prevent
+  // runtime errors like "Cannot read properties of undefined".
+  // Only run for Default Scenario - non-default scenarios will get missing
+  // data filled in from the merge with default scenario data.
+  if (isDefault && structure.dataForMocks && fullScenarioData.data.mockData) {
+    fillMissingMockDataKeysWithDefaults(
+      fullScenarioData.data.mockData,
+      structure.dataForMocks,
+    );
+  }
+
+  // Track the final scenario data for E2E debugging
+  trackDataSnapshot(
+    'generateDataForScenario_result',
+    {
+      scenarioName: scenario.name,
+      mockData: fullScenarioData.data.mockData,
+      argumentsData: fullScenarioData.data.argumentsData,
+    },
+    entity.name,
+    scenario.name,
+  );
+
   return {
     scenarioData: fullScenarioData,
     llmCall: { name: scenario.name, id: llmCall.id },
@@ -176,6 +1168,7 @@ export default async function generateEntityScenarioData({
   entity,
   structure,
   scenarios,
+  executionFlows,
   incompleteResponse,
   analysis,
   model,
@@ -196,6 +1189,7 @@ export default async function generateEntityScenarioData({
       entity,
       structure,
       scenario: defaultScenario,
+      executionFlows,
       incompleteResponse,
       analysis,
       model,
@@ -218,6 +1212,7 @@ export default async function generateEntityScenarioData({
           entity,
           structure,
           scenario,
+          executionFlows,
           defaultScenarioData,
           incompleteResponse,
           analysis,
@@ -238,37 +1233,131 @@ export default async function generateEntityScenarioData({
       );
     }
 
-    scenarioDatas.push(...validResults.map((result) => result.scenarioData));
-    llmCalls.push(...validResults.map((result) => result.llmCall));
+    // Merge non-default scenario data with default scenario data
+    // The LLM generates partial data (only differences), we need to merge with default
+    const mergedScenarioDatas = validResults.map((result) => {
+      const scenarioData = result.scenarioData;
+
+      // Merge mockData with default mockData
+      if (defaultScenarioData.data?.mockData && scenarioData.data?.mockData) {
+        scenarioData.data.mockData = deepMergeScenarioData(
+          defaultScenarioData.data.mockData,
+          scenarioData.data.mockData,
+        );
+      } else if (
+        defaultScenarioData.data?.mockData &&
+        !scenarioData.data?.mockData
+      ) {
+        // Use default mockData if scenario has none
+        scenarioData.data.mockData = { ...defaultScenarioData.data.mockData };
+      }
 
-    console.log('CodeYam Debug: generateEntityScenarioData results', {
-      filePath: entity.filePath,
-      entityName: entity.name,
-      totalScenarios: scenarios.length,
-      defaultScenarioGenerated: !!defaultScenarioResult,
-      otherScenariosRequested: scenarios.length - 1,
-      otherScenariosResults: results.length,
-      nullResults: results.filter((r) => r === null).length,
-      validResults: validResults.length,
-      finalScenarioDatasCount: scenarioDatas.length,
+      // Merge argumentsData with default argumentsData
+      if (
+        defaultScenarioData.data?.argumentsData &&
+        Array.isArray(defaultScenarioData.data.argumentsData) &&
+        scenarioData.data?.argumentsData &&
+        Array.isArray(scenarioData.data.argumentsData)
+      ) {
+        for (
+          let i = 0;
+          i < defaultScenarioData.data.argumentsData.length;
+          i++
+        ) {
+          const scenarioArg = scenarioData.data.argumentsData[i];
+          const defaultArg = defaultScenarioData.data.argumentsData[i];
+
+          // Only merge if both are objects (LLM sometimes returns primitives)
+          if (
+            scenarioArg &&
+            typeof scenarioArg === 'object' &&
+            !Array.isArray(scenarioArg) &&
+            defaultArg &&
+            typeof defaultArg === 'object' &&
+            !Array.isArray(defaultArg)
+          ) {
+            scenarioData.data.argumentsData[i] = deepMergeScenarioData(
+              defaultArg,
+              scenarioArg,
+            );
+          } else if (scenarioArg !== undefined) {
+            // Keep the scenario value as-is (even if primitive)
+            scenarioData.data.argumentsData[i] = scenarioArg;
+          } else if (defaultArg && typeof defaultArg === 'object') {
+            // Use default if scenario is undefined and default is an object
+            scenarioData.data.argumentsData[i] = { ...defaultArg };
+          } else {
+            scenarioData.data.argumentsData[i] = defaultArg;
+          }
+        }
+      } else if (
+        defaultScenarioData.data?.argumentsData &&
+        !scenarioData.data?.argumentsData
+      ) {
+        // Use default argumentsData if scenario has none
+        scenarioData.data.argumentsData =
+          defaultScenarioData.data.argumentsData.map((arg) => ({ ...arg }));
+      }
+
+      // Enforce requiredValues AFTER merge for non-default scenarios
+      // This ensures that if a non-default scenario doesn't cover a certain flow,
+      // it inherits the enforcement from the default scenario
+      if (scenarioData.data?.mockData && executionFlows) {
+        // Get the flows covered by this scenario
+        const scenarioCoveredFlows =
+          nonDefaultScenarios.find(
+            (s) => s.name === result.scenarioData.scenarioDescription,
+          )?.metadata?.coveredFlows || [];
+
+        // Get the paths that the scenario's flows affect
+        const scenarioAffectedPaths = new Set<string>();
+        for (const flowId of scenarioCoveredFlows) {
+          const flow = executionFlows.find((f) => f.id === flowId);
+          if (flow?.requiredValues) {
+            for (const rv of flow.requiredValues) {
+              if (rv.attributePath) {
+                // Extract base path (e.g., "diffView" from "diffView.type")
+                const basePath = rv.attributePath.split('.')[0];
+                scenarioAffectedPaths.add(basePath);
+              }
+            }
+          }
+        }
+
+        // Get the default scenario's flows
+        const defaultCoveredFlows =
+          defaultScenario.metadata?.coveredFlows || [];
+
+        // For paths NOT affected by the scenario, apply default's enforcement
+        const defaultFlowsForUnaffectedPaths = defaultCoveredFlows.filter(
+          (flowId) => {
+            const flow = executionFlows.find((f) => f.id === flowId);
+            if (!flow?.requiredValues) return false;
+
+            // Check if this flow affects a path that the scenario doesn't cover
+            return flow.requiredValues.some((rv) => {
+              if (!rv.attributePath) return false;
+              const basePath = rv.attributePath.split('.')[0];
+              return !scenarioAffectedPaths.has(basePath);
+            });
+          },
+        );
+
+        // Apply enforcement from default scenario for unaffected paths
+        if (defaultFlowsForUnaffectedPaths.length > 0) {
+          enforceRequiredValues(
+            scenarioData.data.mockData,
+            defaultFlowsForUnaffectedPaths,
+            executionFlows,
+          );
+        }
+      }
+
+      return scenarioData;
     });
 
-    awsLog(
-      'CodeYam: scenarioDatas :>> ',
-      JSON.stringify(
-        {
-          filePath: entity.filePath,
-          entityName: entity.name,
-          scenarioDatas: scenarioDatas.map((sd) => ({
-            scenarioName: sd.scenarioName,
-            hasData: !!sd.data,
-            dataKeys: sd.data ? Object.keys(sd.data) : [],
-          })),
-        },
-        null,
-        2,
-      ),
-    );
+    scenarioDatas.push(...mergedScenarioDatas);
+    llmCalls.push(...validResults.map((result) => result.llmCall));
 
     return { scenarioDatas, llmCalls };
   } catch (error) {
@@ -280,186 +1369,312 @@ export default async function generateEntityScenarioData({
 export const generateSystemMessage = (
   scenarioName: string,
   defaultScenario: boolean,
-) => `## Overview
-- You will be provided with a structure for scenario data, the "mockData structure", and for the arguments of the function, the "argumentsData structure", and a scenario describing a new state of data for this function.
-
-- Your goal is to generate data to fulfill both the data structures and the scenario, to be returned in a JSON object.
-
-## Provided Information
-
-- The "mockData structure" and "argumentsData structure" describe all of the data required for the simulation to work. Copy the data structures exactly (if an attribute is a function it will look like "myFunction()" and that exact key "myFunction()" should be in the return value structure) and replace any primitives (e.g. "string", "number", "boolean", "date") with realistic data. 
+  requiresErrorData: boolean = false,
+) => {
+  const scenarioType = defaultScenario
+    ? `## Default Scenario
+Generate COMPLETE, robust data for the entire data structure.
+- Fill ALL fields with realistic values (except error attributes)
+- Do not skip any keys, even simple or small entries
+- Arrays should have 3-5 items to provide realistic test data variety
+- Don't skip nested attributes unless the execution flow requirements specify a parent attribute should be null or undefined
+- This provides the baseline data for all other scenarios`
+    : `## Non-Default Scenario
+Generate ONLY the differences from the default scenario.
+- Include only fields that need to change
+- For object/scalar fields: set to \`null\` to remove/unset the data
+- For array fields: use \`[]\` for empty arrays (not \`null\`) unless the schema type explicitly includes \`| null\`
+- Omit unchanged fields—they merge from default`;
+
+  // Only include the "NO ERROR DATA" instruction when the scenario doesn't require error data
+  const noErrorDataInstruction = requiresErrorData
+    ? `## IMPORTANT: ERROR DATA REQUIRED
+This scenario tests error handling. You MUST include "error" fields with realistic error messages.
+- Set error fields to truthy values (e.g., "Error: Operation failed" or "Something went wrong")
+- The error data is REQUIRED to trigger the correct error UI state`
+    : `## CRITICAL: NO ERROR DATA
+NEVER include "error" fields in responses. Skip them entirely.
+- If structure has \`{ data: {...}, error: {...} }\`, only fill \`data\`
+- Leave out any attribute named "error"—do not set to null, omit entirely`;
+
+  return `You are a test data generator. Create mock data matching a data structure and scenario requirements.
+
+## Execution Flow Requirements
+Each scenario has \`coveredFlows\` which lists the execution flows (distinct outcomes/behaviors) this scenario should demonstrate.
+Each flow has \`requiredValues\` - the attribute values that MUST be set to produce that outcome.
+
+**Your job**: Generate mock data that satisfies ALL the requiredValues from ALL coveredFlows.
+
+For example, if a flow requires:
+\`\`\`json
+{
+  "attributePath": "signature[0].isLoading",
+  "value": "false",
+  "comparison": "equals",
+  "valueType": "boolean"
+}
+\`\`\`
+Then set \`isLoading: false\` in the mockData.
 
-${defaultScenario ? '' : '- The "Default Scenario Data" provides the data that has already been generated for the default scenario. This data will be merged into the data for each scenario. Your goal is to modify this data as needed to satisfy the requirements of this scenario. As such you only need to specify data that is different or should be removed from the default scenario data. To remove data set some portion of the data structure to null.'}
+### Array Length Requirements (length< and length>)
+For array size variation flows:
+- \`comparison: "length<"\` with \`value: "0"\` → generate EMPTY array \`[]\`
+- \`comparison: "length<"\` with \`value: "3"\` → generate 1-2 items (few items)
+- \`comparison: "length>"\` with \`value: "10"\` → generate 12+ items (many items)
 
-- Follow the "keyAttributeInstructions" for the scenario carefully.${defaultScenario ? ' As the Default Scenario ensure that the entire data structure is filled in with appropriate values even if they are not explicitly described in the "keyAttributeInstructions".' : ''}
+### String Length Requirements (normal vs long)
+For text length variation flows:
+- \`value: "normal"\` with \`valueType: "string"\` → generate normal length text (10-50 chars)
+- \`value: "long"\` with \`valueType: "string"\` → generate LONG text (200+ chars) to test overflow/truncation
 
-## Instructions
-${
-  defaultScenario
-    ? `
-- We need data for the default scenario.
+## CRITICAL: Blocking Flows to Avoid
+If the scenario includes \`blockingFlowsToAvoid\`, these are flows (like modals, overlays) that would BLOCK the expected UI.
+You MUST generate mock data that PREVENTS these flows from triggering:
 
-- The default scenario requires robust and complete data that fulfills all the "mockData" and "argumentsData" data structures if they exist, except for error attributes.
+- For \`comparison: "truthy"\` requirements → set the value to \`false\`, \`null\`, \`undefined\`, or \`0\`
+- For \`comparison: "exists"\` requirements → set the value to \`null\` or omit it entirely
+- For \`comparison: "equals"\` requirements → set a DIFFERENT value than what's required
 
-- The one exception to this is error data. Sometimes the data structure will contain structures for both success and error data. In this case you should only fill in the success data and leave out the error data completely.
+For example, if a blocking flow has:
+\`\`\`json
+{
+  "attributePath": "useFetcher().data.success",
+  "value": "true",
+  "comparison": "truthy"
+}
+\`\`\`
+Then you MUST set \`useFetcher().data\` to \`null\` or \`{ success: false }\` to prevent the modal from appearing.
 
-- This data should cover for every object, attribute, and nested attribute described in the data structures (other than error data). If an item in a data structure is an array then provide multiple objects in the array. Fill in every nested attribute with realistic data. This should provide a robust and complete "database" for the simulation. If the type is described as "any" then create a realistic example of that type based on its name. If the type is "date" or "timestamp" then use the instructions below to generate a dynamic date or timestamp. 
+${scenarioType}
 
-- Remember to fill in each and every attribute and nested attribute in the data structure for the default scenario (other than error data). This will make the simulation more realistic and valuable. Do not add any attributes that are not in the data structure. If an attribute is not in the data structure then it should not be included in the data.
-`
-    : `
-- This scenario is a modification of the default scenario. Figure out what needs to change about the Default Scenario in order to satisfy this scenario. If data must be removed then mark is as null at the appropriate level of the structure that the deletion should occur. Otherwise you can change any data that needs to be modified. Do not include any aspect of the structure that should remain the same as the Default Scenario.
+${noErrorDataInstruction}
 
-- The data generated will be merged into the Default Scenario Data in order to create the full data for this scenario.
-`
-}
+## Special Markers
 
-## Example Response
+### Dynamic Dates (\`~~codeyam-code~~\`)
+\`\`\`json
+{ "createdAt": { "~~codeyam-code~~": "new Date(Date.now() - 24*60*60*1000)" } }
+\`\`\`
+Use for relative dates. Code runs in Node (no browser APIs, no external libraries).
 
+### JSX Children (\`~~codeyam-jsx~~\`)
+\`\`\`json
+{ "children": { "~~codeyam-jsx~~": "<div>Hello</div>" } }
+\`\`\`
+Use simple elements only (\`<div>\`, \`<span>\`). No custom components.
+
+### Arrays
+- Arrays should have many items (at least 4) unless specified otherwise
+- Each item must follow the exact structure provided
+- In general we want robust data, not minimal data unless specified otherwise
+- For empty arrays, use \`[]\` (not \`null\`) unless the schema type explicitly includes \`| null\` and the scenario requires the attribute be removed
+
+## CRITICAL: Preserve Exact Structure
+Your response MUST mirror the EXACT nested structure provided in mockData Structure.
+- Do NOT reorganize, split, or create duplicate keys
+- The hierarchy of nested objects must match exactly what was provided unless overridden by scenario rules
+- Only change the leaf VALUES (replacing type descriptions like "string" with actual data like "hello")
+- Copy the key strings EXACTLY from the structure
+- Do NOT modify type parameters, arguments, or any part of the key
+- The keys preserve the exact function call as written in the original code
+
+## Response Format
+\`\`\`json
 {
   "scenarioData": {
-    "scenarioName": ${scenarioName},
-    "data': {
-      "mockData": {
-        "useUser()": {
-          "user": {
-            "name": "John Doe",
-            "metadata": {
-              "hobbies": ["fishing", "hiking", "camping"]
-              "favoriteColor": "blue",
-            },
-            "joinedAt": {
-              "~~codeyam-code~~": "new Date(Date.now() - 3 * 24 * 60 * 60 * 1000)"         
-            }
-          },
-        },
-        "loadProject()": {
-          "project": {
-            "name": "New Project",
-            "slug": "new-project",
-            "files": [
-              {
-                "name": "File 1",
-                "slug": "file-1",
-                "content": "This is the content of file 1"
-              },
-              {
-                "name": "File 2",
-                "slug": "file-2",
-                "content": "This is the content of file 2"
-              },
-              {
-                "name": "File 3",
-                "slug": "file-3",
-                "content": "This is the content of file 3"
-              }
-            ]
-          }
-        }
-      },
-      "argumentsData": [
-        {
-          "open": "true",
-          "children: {
-            "~~codeyam-jsx~~": "<div>Hi!</div>"         
-          }      
-        }    
-      ]  
+    "scenarioName": "${scenarioName}",
+    "data": {
+      "mockData": { ... },
+      "argumentsData": [ ... ]
     }
   }
 }
+\`\`\`
 
-## scenarioData
+## Rules
+- Valid JSON only—no raw code outside markers
+- No \`undefined\`—use \`null\` or omit
+- No data references (can't use \`posts[0]\` elsewhere — duplicate the value)
+- Scenario name must match exactly: "${scenarioName}"
+- Empty mockData: \`{}\`, empty argumentsData: \`[]\`
+
+## IMPORTANT: Avoid Identifier Collisions
+When generating identifier values (SHA hashes, entity IDs, etc.):
+- Use DISTINCT values for different identifier fields
+- Avoid matching: if \`entity.sha\` is "abc123", arrays like \`jobs[].entityShas\` or \`currentlyExecuting.entityShas\` should NOT contain "abc123"
+- This prevents accidental blocking of UI conditionals that check if IDs are in/not-in arrays
+`;
+};
 
-You will return a JSON object called scenarioData containing the name and data for this scenario.
+export const generateIncompleteSystemMessage = (
+  scenarioName: string,
+  isDefault: boolean,
+) => `Your previous response provided us with an incomplete json object.
 
-If you encounter a "date" then you should use "~~codeyam-code~~" along with code in string format. That string will be evaled to create the date or timestamp needed.
+Can you help us complete it? The previous response got cut off because it was too long so to complete the response you'll need to pick up where you left off providing just the necessary text to make the full response a valid json object.
 
-For example the "timestamp" above should probably not be a hard-coded timestamp but should be a function that returns a timestamp. If you want to return a timestamp that is 24 hours in the future, you would return this object:
+Here is the original system message as well:
 
+${generateSystemMessage(scenarioName, isDefault)}
 \`\`\`
+`;
+
+/**
+ * System message for follow-up calls to generate missing mockData keys.
+ * Includes the same rules as the main system message but with a simpler response format.
+ */
+export const generateMissingKeysSystemMessage =
+  () => `You are completing mock data generation for the Default Scenario. The initial response was missing some keys.
+
+Generate data ONLY for the missing keys provided in the prompt. Do not skip any of them.
+
+- Scenario name must match exactly: "Default Scenario"
+
+## Special Markers
+
+### Dynamic Dates (\`~~codeyam-code~~\`)
+\`\`\`json
+{ "createdAt": { "~~codeyam-code~~": "new Date(Date.now() - 24*60*60*1000)" } }
+\`\`\`
+Use for relative dates. Code runs in Node (no browser APIs, no external libraries).
+
+### JSX Children (\`~~codeyam-jsx~~\`)
+\`\`\`json
+{ "children": { "~~codeyam-jsx~~": "<div>Hello</div>" } }
+\`\`\`
+Use simple elements only (\`<div>\`, \`<span>\`). No custom components.
+
+### Arrays
+- Arrays should have many items (at least 4) unless specified otherwise
+- Each item must follow the exact structure provided
+- For empty arrays, use \`[]\` (not \`null\`) unless the schema type explicitly includes \`| null\` and the scenario requires the attribute be removed
+
+## CRITICAL: Preserve Exact Structure
+Your response MUST mirror the EXACT nested structure provided for the missing keys.
+- Only change the leaf VALUES (replacing type descriptions like "string" with actual data)
+- Copy the key strings EXACTLY from the structure
+- Do NOT modify type parameters, arguments, or any part of the key
+
+## CRITICAL: NO ERROR DATA
+NEVER include "error" fields in responses. Skip them entirely.
+- If structure has \`{ data: {...}, error: {...} }\`, only fill \`data\`
+- Leave out any attribute named "error"—do not set to null, omit entirely
+
+## Response Format
+\`\`\`json
 {
-  "scenarioData": {
-    "scenarioName": ${scenarioName},
-    "data": {
-      "mockData": {
-        "dataLoaders": {
-          "fetchUser()": {
-            "user": {
-              "name": "John Doe",
-              "metadata": {
-                "hobbies": ["fishing", "hiking", "camping"],
-                "favoriteColor": "blue"
-              },
-              "joinedAt": {
-                "~~codeyam-code~~": "new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString()"
-              }  
-            }
-          }
-        }
-      }
-    }
+  "mockData": {
+    // fill in ONLY the missing keys
   }
 }
 \`\`\`
 
-Keep in mind the above pattern is also valid for argumentsData.
+## Rules
+- Valid JSON only—no raw code outside markers
+- No \`undefined\`—use \`null\` or omit
+- No data references (can't use \`posts[0]\` elsewhere — duplicate the value)
+`;
 
-All code should be written in JavaScript. It will run in a node environment (not the browser) with no reference to external libraries. It will essentially be run in a sandboxed environment. Do not reference any external libraries in the code.
+/**
+ * System message for focused calls to generate critical mockData keys.
+ * These are keys referenced by the scenario's execution flow requiredValues.
+ */
+export const generateCriticalKeysSystemMessage = (
+  scenarioName: string,
+) => `You are generating mock data for CRITICAL keys that control scenario behavior.
 
-With argumentsData you may also need to return a "children" argument. "children" can either be a string or a jsx element.
+These keys are referenced by the execution flow's requiredValues - they directly determine
+what the component renders. Pay EXTRA attention to matching the exact structure and values.
 
-If you want to return a jsx element you would return something like this:
+- Scenario name must match exactly: "${scenarioName}"
 
-\`\`\`
+## CRITICAL: Special Characters in Keys
+Keys like \`*\` are LITERAL string keys, NOT wildcards or patterns.
+- If the schema shows \`{ "*": "string" }\`, generate \`{ "*": "some value" }\`
+- Do NOT interpret \`*\` as "any key" - use it as an actual key name
+
+## CRITICAL: Preserve Exact Structure
+Your response MUST mirror the EXACT nested structure provided.
+- Copy key strings EXACTLY as shown (including special characters)
+- Only change leaf VALUES (replacing type descriptions with actual data)
+- Do NOT modify keys, type parameters, or add extra keys
+
+## Matching requiredValues
+When the prompt shows requiredValues like:
+- \`attributePath: "useParams().functionCallReturnValue.*"\`
+- \`value: "scenarios"\`
+
+This means set the \`*\` key to include "scenarios". For URL paths split by \`/\`,
+generate a path like \`"scenarios/id/mode"\` where segments match requirements.
+
+## Response Format
+\`\`\`json
 {
   "scenarioData": {
-    "scenarioName": ${scenarioName},
+    "scenarioName": "${scenarioName}",
     "data": {
-      "argumentsData": [
-        {
-          "children": {
-            "~~codeyam-jsx~~": "<div>Click Me!</div>"
-          }
-        }
-      ]
+      "mockData": {
+        // generate data for ONLY the critical keys
+      }
     }
   }
 }
 \`\`\`
 
-The "~~codeyam-jsx~~" key in a "children" prop will be rendered directly to the code as a jsx element, not a string. Only return basic elements like "<div>".
+## Rules
+- Valid JSON only
+- No \`undefined\`—use \`null\` or omit
+- Match the exact schema structure provided
+`;
 
-Do not import or reference any libraries in this code. No external libraries will be imported.
+/**
+ * System message for focused calls to generate mock data for a chunk of keys.
+ * Used when data structures are large and need to be processed in smaller pieces.
+ */
+export const generateChunkSystemMessage = (
+  scenarioName: string,
+) => `You are generating mock data for a SUBSET of keys from a larger data structure.
 
-If either mockData or argumentsData is empty you can return an empty object for mockData ("{}") or empty array for argumentsData ("[]"). 
+This chunk contains fewer keys so you can focus on generating HIGH QUALITY data for each one.
+Pay EXTRA attention to matching the exact structure and values for each key.
 
-If an object inside of mockData or argumentsData is intended to not exist you can set it to null.
+- Scenario name must match exactly: "${scenarioName}"
 
-Never use "~~codeyam-code~~" or "~~codeyam-jsx~~" as a partial key in the response. Even if the key looks like it should have a relative date or code. "~~codeyam-code~~" and "~~codeyam-jsx~~" are only used as independent keys used to mark values that are code.
+## CRITICAL: Special Characters in Keys
+Keys like \`*\` are LITERAL string keys, NOT wildcards or patterns.
+- If the schema shows \`{ "*": "string" }\`, generate \`{ "*": "some value" }\`
+- Do NOT interpret \`*\` as "any key" - use it as an actual key name
 
-## Common Mistakes
+## CRITICAL: Preserve Exact Structure
+Your response MUST mirror the EXACT nested structure provided.
+- Copy key strings EXACTLY as shown (including special characters)
+- Only change leaf VALUES (replacing type descriptions with actual data)
+- Do NOT modify keys, type parameters, or add extra keys
 
-- Do not use the term undefined in the response. If something is missing leave it out or use null.
-- Leave out error data (e.g. a data attribute labeled as "error"), especially when it is in a data structure that has success data as well. Only include the success data and simply leave out the error data. Error data is usually labeled as "error" in the structure. Leave it out entirely.
-  - Please double check this. Ensure no error data is included in the response unless specifically requested. ${defaultScenario ? `This includes the ${`DEFAULT_SCENARIO_NAME`}.` : ''} Leave out any error attributes from the response completely!
-- Do not reference data in the response (e.g. if there was a "posts" field you can not say "posts[0]" elsewhere in the response - you need to duplicate the data). Unfortunately all data must be written out directly in the response.
-- Ensure each scenario in the response matches the full scenario name, commas and all, in the scenarios provided.
-- Do not throw errors from this data in any manner. Simple leave out any error data.
-- If the data structure contains a type that is a "date" then use ~~codeyam-code~~ to generate a dynamic timestamp or date. Do not hard-code dates unless it needs to be a very specific date. Otherwise it should be a relative, dynamic date.
-- The response must be valid JSON. Do not include raw code in the response.
-${defaultScenario ? `- As the ${DEFAULT_SCENARIO_NAME} be very robust in generating data that reflects common real-world usage. All arrays and attributes, except error attributes, should be filled in with high quality data so that default simulation provides a good default of how the function behaves` : ''}
-`;
+## Matching requiredValues
+If the prompt includes requiredValues, these are specific values that MUST be set:
+- For \`attributePath: "useParams().functionCallReturnValue.*"\` with \`value: "scenarios"\`
+  → Set the \`*\` key to include "scenarios" (e.g., "scenarios/id/mode")
+- For URL paths, generate realistic paths that satisfy the requirements
 
-export const generateIncompleteSystemMessage = (
-  scenarioName: string,
-  isDefault: boolean,
-) => `Your previous response provided us with an incomplete json object.
-
-Can you help us complete it? The previous response got cut off because it was too long so to complete the response you'll need to pick up where you left off providing just the necessary text to make the full response a valid json object.
-
-Here is the original system message as well:
+## CRITICAL: NO ERROR DATA
+NEVER include "error" fields in responses. Skip them entirely.
+- If structure has \`{ data: {...}, error: {...} }\`, only fill \`data\`
+- Leave out any attribute named "error"—do not set to null, omit entirely
 
-${generateSystemMessage(scenarioName, isDefault)}
+## Response Format
+\`\`\`json
+{
+  "mockData": {
+    // generate data for ONLY the keys in this chunk
+  }
+}
 \`\`\`
+
+## Rules
+- Valid JSON only
+- No \`undefined\`—use \`null\` or omit
+- Generate data for ALL keys in the chunk (don't skip any)
+- Arrays should have many items (at least 4) unless specified otherwise
+- For empty arrays, use \`[]\` (not \`null\`) unless the schema type explicitly includes \`| null\` and the scenario requires the attribute be removed
 `;