@umituz/react-native-ai-generation-content 1.35.9 → 1.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.35.9",
+  "version": "1.36.0",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.executor.ts

@@ -0,0 +1,113 @@
+/**
+ * Image Generation Executor
+ * Handles the actual image generation execution
+ */
+
+import { buildFacePreservationPrompt } from "../../../../prompts/infrastructure/builders/face-preservation-builder";
+import { buildInteractionStylePrompt } from "../../../../prompts/infrastructure/builders/interaction-style-builder";
+import type { ImageGenerationInput } from "./image-generation.types";
+import {
+  GENERATION_TIMEOUT_MS,
+  BASE64_IMAGE_PREFIX,
+  DEFAULT_STYLE_VALUE,
+  MODEL_INPUT_DEFAULTS,
+} from "./wizard-strategy.constants";
+
+declare const __DEV__: boolean;
+
+interface ExecutionResult {
+  success: boolean;
+  imageUrl?: string;
+  error?: string;
+}
+
+/**
+ * Formats base64 string with proper data URI prefix
+ */
+function formatBase64(base64: string): string {
+  return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
+}
+
+/**
+ * Builds the final prompt based on input type (photo-based or text-to-image)
+ */
+function buildFinalPrompt(input: ImageGenerationInput, imageUrls: string[]): string {
+  const hasPhotos = imageUrls.length > 0;
+
+  if (hasPhotos) {
+    const facePrompt = buildFacePreservationPrompt({
+      scenarioPrompt: input.prompt,
+      personCount: imageUrls.length,
+    });
+
+    const interactionPrompt = buildInteractionStylePrompt({
+      style: input.interactionStyle ?? "romantic",
+      personCount: imageUrls.length,
+    });
+
+    return interactionPrompt ? `${facePrompt}\n\n${interactionPrompt}` : facePrompt;
+  }
+
+  // Text-to-image with optional style
+  if (input.style && input.style !== DEFAULT_STYLE_VALUE) {
+    return `${input.prompt}. Style: ${input.style}`;
+  }
+
+  return input.prompt;
+}
+
+/**
+ * Executes image generation using the AI provider
+ */
+export async function executeImageGeneration(
+  input: ImageGenerationInput,
+  model: string,
+  onProgress?: (progress: number) => void,
+): Promise<ExecutionResult> {
+  const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
+
+  const provider = providerRegistry.getActiveProvider();
+  if (!provider?.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  try {
+    const imageUrls = input.photos.map(formatBase64);
+    const finalPrompt = buildFinalPrompt(input, imageUrls);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      const mode = imageUrls.length > 0 ? "Photo-based" : "Text-to-image";
+      console.log(`[ImageExecutor] ${mode} generation`, { personCount: imageUrls.length });
+    }
+
+    const modelInput: Record<string, unknown> = {
+      prompt: finalPrompt,
+      aspect_ratio: MODEL_INPUT_DEFAULTS.aspectRatio,
+      output_format: MODEL_INPUT_DEFAULTS.outputFormat,
+      num_images: MODEL_INPUT_DEFAULTS.numImages,
+      enable_safety_checker: MODEL_INPUT_DEFAULTS.enableSafetyChecker,
+    };
+
+    if (imageUrls.length > 0) {
+      modelInput.image_urls = imageUrls;
+    }
+
+    let lastStatus = "";
+    const result = await provider.subscribe(model, modelInput, {
+      timeoutMs: GENERATION_TIMEOUT_MS,
+      onQueueUpdate: (status) => {
+        if (status.status !== lastStatus) lastStatus = status.status;
+      },
+    });
+
+    const rawResult = result as Record<string, unknown>;
+    const data = (rawResult?.data ?? rawResult) as { images?: Array<{ url: string }> };
+    const imageUrl = data?.images?.[0]?.url;
+
+    onProgress?.(100);
+
+    return imageUrl ? { success: true, imageUrl } : { success: false, error: "No image generated" };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : "Generation failed" };
+  }
+}

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.strategy.ts

@@ -3,159 +3,18 @@
  * Handles image-specific generation logic
  */
 
-import { readFileAsBase64 } from "@umituz/react-native-design-system";
 import { createCreationsRepository } from "../../../../creations/infrastructure/adapters";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
-import {
-  GENERATION_TIMEOUT_MS,
-  BASE64_IMAGE_PREFIX,
-  PHOTO_KEY_PREFIX,
-  DEFAULT_STYLE_VALUE,
-  MODEL_INPUT_DEFAULTS,
-  IMAGE_PROCESSING_PROMPTS,
-} from "./wizard-strategy.constants";
-import { buildFacePreservationPrompt } from "../../../../prompts/infrastructure/builders/face-preservation-builder";
-import { buildInteractionStylePrompt, type InteractionStyle } from "../../../../prompts/infrastructure/builders/interaction-style-builder";
+import { DEFAULT_STYLE_VALUE, IMAGE_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
+import type { InteractionStyle } from "../../../../prompts/infrastructure/builders/interaction-style-builder";
 import { extractPrompt, extractSelection } from "../utils";
+import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
+import { executeImageGeneration } from "./image-generation.executor";
+import type { ImageGenerationInput, CreateImageStrategyOptions } from "./image-generation.types";
 
-declare const __DEV__: boolean;
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface ImageGenerationInput {
-  /** Photos are optional for text-to-image */
-  readonly photos: readonly string[];
-  readonly prompt: string;
-  /** Optional interaction style for multi-person images */
-  readonly interactionStyle?: InteractionStyle;
-  /** Optional style from wizard selection */
-  readonly style?: string;
-}
-
-export interface ImageGenerationResult {
-  readonly imageUrl: string;
-}
-
-// ============================================================================
-// Photo Extraction
-// ============================================================================
-
-async function extractPhotosFromWizardData(
-  wizardData: Record<string, unknown>,
-): Promise<string[]> {
-  const photoKeys = Object.keys(wizardData)
-    .filter((k) => k.includes(PHOTO_KEY_PREFIX))
-    .sort();
-
-  if (photoKeys.length === 0) {
-    return [];
-  }
-
-  const photoUris: string[] = [];
-  for (const key of photoKeys) {
-    const photo = wizardData[key] as { uri?: string };
-    if (photo?.uri) {
-      photoUris.push(photo.uri);
-    }
-  }
-
-  if (photoUris.length === 0) {
-    return [];
-  }
-
-  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
-  return photosBase64.filter(Boolean) as string[];
-}
-
-// ============================================================================
-// Image Generation Executor
-// ============================================================================
-
-async function executeImageGeneration(
-  input: ImageGenerationInput,
-  model: string,
-  onProgress?: (progress: number) => void,
-): Promise<{ success: boolean; imageUrl?: string; error?: string }> {
-  const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
-
-  const provider = providerRegistry.getActiveProvider();
-  if (!provider?.isInitialized()) {
-    return { success: false, error: "AI provider not initialized" };
-  }
-
-  try {
-    const formatBase64 = (base64: string): string =>
-      base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
-
-    const hasPhotos = input.photos.length > 0;
-    const imageUrls = hasPhotos ? input.photos.map(formatBase64) : [];
-
-    let finalPrompt = input.prompt;
-
-    if (hasPhotos) {
-      // Photo-based: Build face preservation prompt
-      const facePrompt = buildFacePreservationPrompt({
-        scenarioPrompt: input.prompt,
-        personCount: imageUrls.length,
-      });
-
-      const interactionPrompt = buildInteractionStylePrompt({
-        style: input.interactionStyle ?? "romantic",
-        personCount: imageUrls.length,
-      });
-
-      finalPrompt = interactionPrompt
-        ? `${facePrompt}\n\n${interactionPrompt}`
-        : facePrompt;
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageStrategy] Photo-based generation for", imageUrls.length, "person(s)");
-      }
-    } else {
-      // Text-to-image: Use prompt with optional style
-      if (input.style && input.style !== DEFAULT_STYLE_VALUE) {
-        finalPrompt = `${input.prompt}. Style: ${input.style}`;
-      }
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageStrategy] Text-to-image generation");
-      }
-    }
-
-    const modelInput: Record<string, unknown> = {
-      prompt: finalPrompt,
-      aspect_ratio: MODEL_INPUT_DEFAULTS.aspectRatio,
-      output_format: MODEL_INPUT_DEFAULTS.outputFormat,
-      num_images: MODEL_INPUT_DEFAULTS.numImages,
-      enable_safety_checker: MODEL_INPUT_DEFAULTS.enableSafetyChecker,
-    };
-
-    if (hasPhotos) {
-      modelInput.image_urls = imageUrls;
-    }
-
-    let lastStatus = "";
-    const result = await provider.subscribe(model, modelInput, {
-      timeoutMs: GENERATION_TIMEOUT_MS,
-      onQueueUpdate: (status) => {
-        if (status.status !== lastStatus) lastStatus = status.status;
-      },
-    });
-
-    const rawResult = result as Record<string, unknown>;
-    const data = (rawResult?.data ?? rawResult) as { images?: Array<{ url: string }> };
-    const imageUrl = data?.images?.[0]?.url;
-
-    onProgress?.(100);
-
-    return imageUrl ? { success: true, imageUrl } : { success: false, error: "No image generated" };
-  } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : "Generation failed" };
-  }
-}
+// Re-export types for external use
+export type { ImageGenerationInput, ImageGenerationResult, CreateImageStrategyOptions } from "./image-generation.types";
 
 // ============================================================================
 // Input Builder
@@ -165,69 +24,62 @@ export async function buildImageInput(
   wizardData: Record<string, unknown>,
   scenario: WizardScenarioData,
 ): Promise<ImageGenerationInput | null> {
-  const photos = await extractPhotosFromWizardData(wizardData);
+  const photos = await extractPhotosAsBase64(wizardData);
 
-  // Extract prompt using type-safe extractor with fallback
+  // Extract prompt with fallback to default
   let prompt = extractPrompt(wizardData, scenario.aiPrompt);
 
-  // For image processing features, use default prompt if none provided
   if (!prompt) {
     const defaultPrompt = IMAGE_PROCESSING_PROMPTS[scenario.id];
     if (defaultPrompt) {
       prompt = defaultPrompt;
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ImageStrategy] Using default prompt for", scenario.id);
-      }
     } else {
       throw new Error("Prompt is required for image generation");
     }
   }
 
-  // For photo-based generation, apply style enhancements
+  // Apply style enhancements for photo-based generation
   let finalPrompt = prompt;
   if (photos.length > 0) {
-    const styleEnhancements: string[] = [];
+    finalPrompt = applyStyleEnhancements(prompt, wizardData);
+  }
 
-    // Extract selections using type-safe extractor
-    const romanticMoods = extractSelection(wizardData.selection_romantic_mood);
-    if (Array.isArray(romanticMoods) && romanticMoods.length > 0) {
-      styleEnhancements.push(`Mood: ${romanticMoods.join(", ")}`);
-    }
+  // Extract style for text-to-image
+  const styleValue = extractSelection(wizardData.style);
+  const style = typeof styleValue === "string" ? styleValue : undefined;
+  const interactionStyle = (scenario.interactionStyle as InteractionStyle) ?? "romantic";
 
-    const artStyle = extractSelection(wizardData.selection_art_style);
-    if (typeof artStyle === "string" && artStyle !== DEFAULT_STYLE_VALUE) {
-      styleEnhancements.push(`Art style: ${artStyle}`);
-    }
+  return { photos, prompt: finalPrompt, style, interactionStyle };
+}
 
-    const artist = extractSelection(wizardData.selection_artist_style);
-    if (typeof artist === "string" && artist !== DEFAULT_STYLE_VALUE) {
-      styleEnhancements.push(`Artist style: ${artist}`);
-    }
+/**
+ * Applies style enhancements to the prompt
+ */
+function applyStyleEnhancements(prompt: string, wizardData: Record<string, unknown>): string {
+  const enhancements: string[] = [];
 
-    if (styleEnhancements.length > 0) {
-      finalPrompt = `${prompt}. ${styleEnhancements.join(", ")}`;
-    }
+  const romanticMoods = extractSelection(wizardData.selection_romantic_mood);
+  if (Array.isArray(romanticMoods) && romanticMoods.length > 0) {
+    enhancements.push(`Mood: ${romanticMoods.join(", ")}`);
   }
 
-  // Extract style using type-safe extractor (for text-to-image)
-  const styleValue = extractSelection(wizardData.style);
-  const style = typeof styleValue === "string" ? styleValue : undefined;
+  const artStyle = extractSelection(wizardData.selection_art_style);
+  if (typeof artStyle === "string" && artStyle !== DEFAULT_STYLE_VALUE) {
+    enhancements.push(`Art style: ${artStyle}`);
+  }
 
-  // Get interaction style from scenario (default: romantic for couple apps)
-  const interactionStyle = (scenario.interactionStyle as InteractionStyle) ?? "romantic";
+  const artist = extractSelection(wizardData.selection_artist_style);
+  if (typeof artist === "string" && artist !== DEFAULT_STYLE_VALUE) {
+    enhancements.push(`Artist style: ${artist}`);
+  }
 
-  return { photos, prompt: finalPrompt, style, interactionStyle };
+  return enhancements.length > 0 ? `${prompt}. ${enhancements.join(", ")}` : prompt;
 }
 
 // ============================================================================
 // Strategy Factory
 // ============================================================================
 
-export interface CreateImageStrategyOptions {
-  readonly scenario: WizardScenarioData;
-  readonly collectionName?: string;
-}
-
 export function createImageStrategy(options: CreateImageStrategyOptions): WizardStrategy {
   const { scenario, collectionName = "creations" } = options;
   const repository = createCreationsRepository(collectionName);

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.types.ts

@@ -0,0 +1,26 @@
+/**
+ * Image Generation Types
+ * Type definitions for image generation strategy
+ */
+
+import type { InteractionStyle } from "../../../../prompts/infrastructure/builders/interaction-style-builder";
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+
+export interface ImageGenerationInput {
+  /** Photos are optional for text-to-image */
+  readonly photos: readonly string[];
+  readonly prompt: string;
+  /** Optional interaction style for multi-person images */
+  readonly interactionStyle?: InteractionStyle;
+  /** Optional style from wizard selection */
+  readonly style?: string;
+}
+
+export interface ImageGenerationResult {
+  readonly imageUrl: string;
+}
+
+export interface CreateImageStrategyOptions {
+  readonly scenario: WizardScenarioData;
+  readonly collectionName?: string;
+}

package/src/domains/generation/wizard/infrastructure/strategies/shared/photo-extraction.utils.ts

@@ -0,0 +1,70 @@
+/**
+ * Photo Extraction Utilities
+ * Shared photo extraction logic for wizard strategies
+ */
+
+import { readFileAsBase64 } from "@umituz/react-native-design-system";
+import { PHOTO_KEY_PREFIX } from "../wizard-strategy.constants";
+
+declare const __DEV__: boolean;
+
+/**
+ * Extracts photo URIs from wizard data
+ */
+function extractPhotoUris(wizardData: Record<string, unknown>): string[] {
+  const photoKeys = Object.keys(wizardData)
+    .filter((k) => k.includes(PHOTO_KEY_PREFIX))
+    .sort();
+
+  if (photoKeys.length === 0) {
+    return [];
+  }
+
+  const photoUris: string[] = [];
+  for (const key of photoKeys) {
+    const photo = wizardData[key] as { uri?: string };
+    if (photo?.uri) {
+      photoUris.push(photo.uri);
+    }
+  }
+
+  return photoUris;
+}
+
+/**
+ * Extracts and converts photos to base64 from wizard data
+ * Used by both image and video strategies
+ */
+export async function extractPhotosAsBase64(
+  wizardData: Record<string, unknown>,
+  enableDebugLogs = false,
+): Promise<string[]> {
+  if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[PhotoExtraction] Starting extraction", {
+      wizardDataKeys: Object.keys(wizardData),
+    });
+  }
+
+  const photoUris = extractPhotoUris(wizardData);
+
+  if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[PhotoExtraction] Found photo URIs", { count: photoUris.length });
+  }
+
+  if (photoUris.length === 0) {
+    return [];
+  }
+
+  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
+  const validPhotos = photosBase64.filter(Boolean) as string[];
+
+  if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[PhotoExtraction] Converted photos", {
+      total: photoUris.length,
+      valid: validPhotos.length,
+      sizes: validPhotos.map((p) => `${(p.length / 1024).toFixed(1)}KB`),
+    });
+  }
+
+  return validPhotos;
+}

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.strategy.ts

@@ -3,122 +3,20 @@
  * Handles video-specific generation logic
  */
 
-import { readFileAsBase64 } from "@umituz/react-native-design-system";
-import type { VideoFeatureType } from "../../../../../domain/interfaces";
 import { executeVideoFeature } from "../../../../../infrastructure/services/video-feature-executor.service";
 import { createCreationsRepository } from "../../../../creations/infrastructure/adapters";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
-import { PHOTO_KEY_PREFIX, VIDEO_FEATURE_PATTERNS, VIDEO_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
-
-declare const __DEV__: boolean;
+import { VIDEO_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
 import { extractPrompt, extractDuration, extractAspectRatio, extractResolution } from "../utils";
+import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
+import { getVideoFeatureType } from "./video-generation.utils";
+import type { VideoGenerationInput, CreateVideoStrategyOptions } from "./video-generation.types";
 
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface VideoGenerationInput {
-  /** Source image (optional for text-to-video) */
-  readonly sourceImageBase64?: string;
-  /** Target image (optional, uses source if not provided) */
-  readonly targetImageBase64?: string;
-  readonly prompt: string;
-  /** Video duration in seconds */
-  readonly duration?: number;
-  /** Aspect ratio (e.g., "16:9", "9:16") */
-  readonly aspectRatio?: string;
-  /** Video resolution (e.g., "720p", "1080p") */
-  readonly resolution?: string;
-}
-
-export interface VideoGenerationResult {
-  readonly videoUrl: string;
-}
-
-// ============================================================================
-// Photo Extraction
-// ============================================================================
-
-async function extractPhotosFromWizardData(
-  wizardData: Record<string, unknown>,
-): Promise<string[]> {
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:extractPhotos] Starting extraction", {
-      wizardDataKeys: Object.keys(wizardData),
-    });
-  }
-
-  const photoKeys = Object.keys(wizardData)
-    .filter((k) => k.includes(PHOTO_KEY_PREFIX))
-    .sort();
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:extractPhotos] Found photo keys", { photoKeys });
-  }
-
-  if (photoKeys.length === 0) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoStrategy:extractPhotos] No photo keys found");
-    }
-    return [];
-  }
-
-  const photoUris: string[] = [];
-  for (const key of photoKeys) {
-    const photo = wizardData[key] as { uri?: string };
-    if (photo?.uri) {
-      photoUris.push(photo.uri);
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoStrategy:extractPhotos] Found photo URI", { key, uri: photo.uri.substring(0, 50) + "..." });
-      }
-    }
-  }
-
-  if (photoUris.length === 0) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoStrategy:extractPhotos] No photo URIs found");
-    }
-    return [];
-  }
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:extractPhotos] Converting to base64", { count: photoUris.length });
-  }
-
-  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
-  const validPhotos = photosBase64.filter(Boolean) as string[];
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:extractPhotos] Converted photos", {
-      total: photoUris.length,
-      valid: validPhotos.length,
-      sizes: validPhotos.map((p) => `${(p.length / 1024).toFixed(1)}KB`),
-    });
-  }
-
-  return validPhotos;
-}
-
-// ============================================================================
-// Video Feature Type Detection
-// ============================================================================
-
-function getVideoFeatureType(scenarioId: string): VideoFeatureType {
-  const id = scenarioId.toLowerCase();
-
-  for (const [pattern, featureType] of Object.entries(VIDEO_FEATURE_PATTERNS)) {
-    if (id.includes(pattern)) {
-      return featureType;
-    }
-  }
+declare const __DEV__: boolean;
 
-  // Default to image-to-video for content scenarios (they take a photo and generate video)
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:getFeatureType] Defaulting to image-to-video for content scenario", { scenarioId });
-  }
-  return "image-to-video";
-}
+// Re-export types for external use
+export type { VideoGenerationInput, VideoGenerationResult, CreateVideoStrategyOptions } from "./video-generation.types";
 
 // ============================================================================
 // Input Builder
@@ -129,79 +27,37 @@ export async function buildVideoInput(
   scenario: WizardScenarioData,
 ): Promise<VideoGenerationInput | null> {
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:buildInput] START", {
-      scenarioId: scenario.id,
-      outputType: scenario.outputType,
-      hasAiPrompt: !!scenario.aiPrompt,
-    });
+    console.log("[VideoStrategy] Building input", { scenarioId: scenario.id });
   }
 
-  const photos = await extractPhotosFromWizardData(wizardData);
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:buildInput] Photos extracted", {
-      count: photos.length,
-      hasSource: !!photos[0],
-      hasTarget: !!photos[1],
-    });
-  }
+  const photos = await extractPhotosAsBase64(wizardData, true);
 
-  // Extract prompt using type-safe extractor with fallback
+  // Extract prompt with fallback to default
   let prompt = extractPrompt(wizardData, scenario.aiPrompt);
 
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:buildInput] Prompt from wizard", {
-      hasPrompt: !!prompt,
-      promptLength: prompt?.length ?? 0,
-    });
-  }
-
-  // For video processing features, use default prompt if none provided
   if (!prompt) {
     const defaultPrompt = VIDEO_PROCESSING_PROMPTS[scenario.id];
     if (defaultPrompt) {
       prompt = defaultPrompt;
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoStrategy:buildInput] Using default prompt", {
-          scenarioId: scenario.id,
-          prompt: prompt.substring(0, 50) + "...",
-        });
-      }
     } else {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoStrategy:buildInput] ERROR: No prompt available", {
-          scenarioId: scenario.id,
-          availablePrompts: Object.keys(VIDEO_PROCESSING_PROMPTS),
-        });
-      }
       throw new Error("Prompt is required for video generation");
     }
   }
 
-  // Extract video generation parameters
-  const duration = extractDuration(wizardData);
-  const aspectRatio = extractAspectRatio(wizardData);
-  const resolution = extractResolution(wizardData);
-
   const input: VideoGenerationInput = {
     sourceImageBase64: photos[0],
     targetImageBase64: photos[1] || photos[0],
     prompt,
-    duration,
-    aspectRatio,
-    resolution,
+    duration: extractDuration(wizardData),
+    aspectRatio: extractAspectRatio(wizardData),
+    resolution: extractResolution(wizardData),
   };
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:buildInput] COMPLETE", {
+    console.log("[VideoStrategy] Input built", {
       hasSource: !!input.sourceImageBase64,
       hasTarget: !!input.targetImageBase64,
-      sourceSize: input.sourceImageBase64 ? `${(input.sourceImageBase64.length / 1024).toFixed(1)}KB` : "N/A",
-      targetSize: input.targetImageBase64 ? `${(input.targetImageBase64.length / 1024).toFixed(1)}KB` : "N/A",
-      prompt: input.prompt.substring(0, 50) + "...",
       duration: input.duration,
-      aspectRatio: input.aspectRatio,
-      resolution: input.resolution,
     });
   }
 
@@ -212,22 +68,13 @@ export async function buildVideoInput(
 // Strategy Factory
 // ============================================================================
 
-export interface CreateVideoStrategyOptions {
-  readonly scenario: WizardScenarioData;
-  readonly collectionName?: string;
-}
-
 export function createVideoStrategy(options: CreateVideoStrategyOptions): WizardStrategy {
   const { scenario, collectionName = "creations" } = options;
   const repository = createCreationsRepository(collectionName);
   const videoFeatureType = getVideoFeatureType(scenario.id);
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy:create] Created strategy", {
-      scenarioId: scenario.id,
-      videoFeatureType,
-      collectionName,
-    });
+    console.log("[VideoStrategy] Created", { scenarioId: scenario.id, videoFeatureType });
   }
 
   let lastInputRef: VideoGenerationInput | null = null;
@@ -237,51 +84,21 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
       const videoInput = input as VideoGenerationInput;
       lastInputRef = videoInput;
 
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoStrategy:execute] START", {
-          featureType: videoFeatureType,
-          hasSource: !!videoInput.sourceImageBase64,
-          hasTarget: !!videoInput.targetImageBase64,
-          prompt: videoInput.prompt.substring(0, 50) + "...",
-        });
-      }
-
-      const result = await executeVideoFeature(
-        videoFeatureType,
-        {
-          sourceImageBase64: videoInput.sourceImageBase64,
-          targetImageBase64: videoInput.targetImageBase64,
-          prompt: videoInput.prompt,
-          options: {
-            duration: videoInput.duration,
-            aspect_ratio: videoInput.aspectRatio,
-            resolution: videoInput.resolution,
-          },
+      const result = await executeVideoFeature(videoFeatureType, {
+        sourceImageBase64: videoInput.sourceImageBase64,
+        targetImageBase64: videoInput.targetImageBase64,
+        prompt: videoInput.prompt,
+        options: {
+          duration: videoInput.duration,
+          aspect_ratio: videoInput.aspectRatio,
+          resolution: videoInput.resolution,
         },
-      );
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoStrategy:execute] RESULT", {
-          success: result.success,
-          hasVideoUrl: !!result.videoUrl,
-          error: result.error,
-          requestId: result.requestId,
-        });
-      }
+      });
 
       if (!result.success || !result.videoUrl) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[VideoStrategy:execute] FAILED", { error: result.error });
-        }
         throw new Error(result.error || "Video generation failed");
       }
 
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoStrategy:execute] SUCCESS", {
-          videoUrl: result.videoUrl.substring(0, 80) + "...",
-        });
-      }
-
       return { videoUrl: result.videoUrl };
     },
 

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.types.ts

@@ -0,0 +1,29 @@
+/**
+ * Video Generation Types
+ * Type definitions for video generation strategy
+ */
+
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+
+export interface VideoGenerationInput {
+  /** Source image (optional for text-to-video) */
+  readonly sourceImageBase64?: string;
+  /** Target image (optional, uses source if not provided) */
+  readonly targetImageBase64?: string;
+  readonly prompt: string;
+  /** Video duration in seconds */
+  readonly duration?: number;
+  /** Aspect ratio (e.g., "16:9", "9:16") */
+  readonly aspectRatio?: string;
+  /** Video resolution (e.g., "720p", "1080p") */
+  readonly resolution?: string;
+}
+
+export interface VideoGenerationResult {
+  readonly videoUrl: string;
+}
+
+export interface CreateVideoStrategyOptions {
+  readonly scenario: WizardScenarioData;
+  readonly collectionName?: string;
+}

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.utils.ts

@@ -0,0 +1,28 @@
+/**
+ * Video Generation Utilities
+ * Video-specific utility functions
+ */
+
+import type { VideoFeatureType } from "../../../../../domain/interfaces";
+import { VIDEO_FEATURE_PATTERNS } from "./wizard-strategy.constants";
+
+declare const __DEV__: boolean;
+
+/**
+ * Determines the video feature type based on scenario ID
+ */
+export function getVideoFeatureType(scenarioId: string): VideoFeatureType {
+  const id = scenarioId.toLowerCase();
+
+  for (const [pattern, featureType] of Object.entries(VIDEO_FEATURE_PATTERNS)) {
+    if (id.includes(pattern)) {
+      return featureType;
+    }
+  }
+
+  // Default to image-to-video for content scenarios
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoUtils] Defaulting to image-to-video", { scenarioId });
+  }
+  return "image-to-video";
+}

package/src/domains/generation/wizard/presentation/components/GenericWizardFlow.tsx

@@ -43,7 +43,7 @@ export interface GenericWizardFlowProps {
   readonly scenario?: WizardScenarioData;
   readonly scenarioId?: string;
   readonly userId?: string;
-  readonly alertMessages?: AlertMessages;
+  readonly alertMessages: AlertMessages;
   readonly skipResultStep?: boolean;
   readonly onStepChange?: (stepId: string, stepType: StepType | string) => void;
   readonly onGenerationStart?: (

package/src/domains/prompts/index.ts

@@ -89,14 +89,18 @@ export {
   PHOTOREALISTIC_RENDERING,
   NATURAL_POSE_GUIDELINES,
   MASTER_BASE_PROMPT,
-  MULTI_PERSON_PRESERVATION_RULES,
   createEnhancedPrompt,
   createTransformationPrompt,
   enhanceExistingPrompt,
-  createMultiPersonPrompt,
 } from './domain/entities/BasePromptStructure';
 export type { CreatePromptOptions } from './domain/entities/BasePromptStructure';
 
+export {
+  MULTI_PERSON_PRESERVATION_RULES,
+  createMultiPersonPrompt,
+} from './domain/entities/MultiPersonPromptStructure';
+export type { MultiPersonPreservationRules } from './domain/entities/MultiPersonPromptStructure';
+
 export {
   buildFacePreservationPrompt,
   buildMinimalFacePreservationPrompt,