@umituz/react-native-ai-generation-content 1.26.36 → 1.26.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.26.36",
+  "version": "1.26.39",
   "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.strategy.ts

@@ -0,0 +1,219 @@
+/**
+ * Image Generation Strategy
+ * 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,
+} from "./wizard-strategy.constants";
+
+declare const __DEV__: boolean;
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ImageGenerationInput {
+  readonly photos: readonly string[];
+  readonly prompt: string;
+}
+
+export interface ImageGenerationResult {
+  readonly imageUrl: string;
+}
+
+// ============================================================================
+// Photo Extraction
+// ============================================================================
+
+async function extractPhotosFromWizardData(
+  wizardData: Record<string, unknown>,
+): Promise<string[] | null> {
+  const photoKeys = Object.keys(wizardData)
+    .filter((k) => k.includes(PHOTO_KEY_PREFIX))
+    .sort();
+
+  if (photoKeys.length === 0) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[ImageStrategy] No photos found", { keys: Object.keys(wizardData) });
+    }
+    return null;
+  }
+
+  const photoUris: string[] = [];
+  for (const key of photoKeys) {
+    const photo = wizardData[key] as { uri?: string };
+    if (!photo?.uri) return null;
+    photoUris.push(photo.uri);
+  }
+
+  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
+  const validPhotos = photosBase64.filter(Boolean) as string[];
+
+  return validPhotos.length > 0 ? validPhotos : null;
+}
+
+// ============================================================================
+// 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 imageUrls = input.photos.map(formatBase64);
+    if (imageUrls.length === 0) {
+      return { success: false, error: "At least one image required" };
+    }
+
+    const enhancedPrompt = `Create a photorealistic image featuring the exact two people from the provided photos. Use the person from @image1 and the person from @image2 exactly as they appear in the reference images - maintain their facial features, expressions, and identity. ${input.prompt}. Professional photography, high quality, detailed, natural lighting, photorealistic rendering.`;
+
+    const modelInput = {
+      image_urls: imageUrls,
+      prompt: enhancedPrompt,
+      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,
+    };
+
+    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" };
+  }
+}
+
+// ============================================================================
+// Input Builder
+// ============================================================================
+
+export async function buildImageInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<ImageGenerationInput | null> {
+  const photos = await extractPhotosFromWizardData(wizardData);
+  if (!photos) return null;
+
+  if (!scenario.aiPrompt?.trim()) {
+    throw new Error(`Scenario "${scenario.id}" must have aiPrompt field`);
+  }
+
+  let prompt = scenario.aiPrompt;
+
+  const styleEnhancements: string[] = [];
+
+  const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
+  if (romanticMoods?.length) {
+    styleEnhancements.push(`Mood: ${romanticMoods.join(", ")}`);
+  }
+
+  const artStyle = wizardData.selection_art_style as string | undefined;
+  if (artStyle && artStyle !== DEFAULT_STYLE_VALUE) {
+    styleEnhancements.push(`Art style: ${artStyle}`);
+  }
+
+  const artist = wizardData.selection_artist_style as string | undefined;
+  if (artist && artist !== DEFAULT_STYLE_VALUE) {
+    styleEnhancements.push(`Artist style: ${artist}`);
+  }
+
+  if (styleEnhancements.length > 0) {
+    prompt = `${prompt}. ${styleEnhancements.join(", ")}`;
+  }
+
+  return { photos, 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);
+
+  let lastInputRef: ImageGenerationInput | null = null;
+
+  return {
+    execute: async (input: unknown, onProgress) => {
+      const imageInput = input as ImageGenerationInput;
+      if (!scenario.model) {
+        throw new Error("Model is required for image generation");
+      }
+
+      lastInputRef = imageInput;
+
+      const result = await executeImageGeneration(imageInput, scenario.model, onProgress);
+
+      if (!result.success || !result.imageUrl) {
+        throw new Error(result.error || "Image generation failed");
+      }
+
+      return { imageUrl: result.imageUrl };
+    },
+
+    getCreditCost: () => 1,
+
+    save: async (result: unknown, uid) => {
+      const input = lastInputRef;
+      const imageResult = result as { imageUrl?: string };
+      if (!input || !scenario?.id || !imageResult.imageUrl) return;
+
+      const creation = {
+        id: `${scenario.id}_${Date.now()}`,
+        uri: imageResult.imageUrl,
+        type: scenario.id,
+        prompt: input.prompt,
+        createdAt: new Date(),
+        isShared: false,
+        isFavorite: false,
+        metadata: {
+          scenarioId: scenario.id,
+          scenarioTitle: scenario.title || scenario.id,
+        },
+        output: { imageUrl: imageResult.imageUrl },
+      };
+
+      await repository.create(uid, creation);
+    },
+  };
+}

package/src/domains/generation/wizard/infrastructure/strategies/index.ts

@@ -1,2 +1,2 @@
 export { createWizardStrategy, buildWizardInput } from './wizard-strategy.factory';
-export type { CreateWizardStrategyOptions } from './wizard-strategy.factory';
+export type { CreateWizardStrategyOptions, WizardStrategy } from './wizard-strategy.factory';

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

@@ -0,0 +1,162 @@
+/**
+ * Video Generation Strategy
+ * 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 } from "./wizard-strategy.constants";
+
+declare const __DEV__: boolean;
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface VideoGenerationInput {
+  readonly sourceImageBase64: string;
+  readonly targetImageBase64: string;
+  readonly prompt: string;
+}
+
+export interface VideoGenerationResult {
+  readonly videoUrl: string;
+}
+
+// ============================================================================
+// Photo Extraction
+// ============================================================================
+
+async function extractPhotosFromWizardData(
+  wizardData: Record<string, unknown>,
+): Promise<string[] | null> {
+  const photoKeys = Object.keys(wizardData)
+    .filter((k) => k.includes(PHOTO_KEY_PREFIX))
+    .sort();
+
+  if (photoKeys.length === 0) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[VideoStrategy] No photos found", { keys: Object.keys(wizardData) });
+    }
+    return null;
+  }
+
+  const photoUris: string[] = [];
+  for (const key of photoKeys) {
+    const photo = wizardData[key] as { uri?: string };
+    if (!photo?.uri) return null;
+    photoUris.push(photo.uri);
+  }
+
+  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
+  const validPhotos = photosBase64.filter(Boolean) as string[];
+
+  return validPhotos.length > 0 ? validPhotos : null;
+}
+
+// ============================================================================
+// 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;
+    }
+  }
+
+  throw new Error(`Unknown video feature type for scenario "${scenarioId}". Add pattern to VIDEO_FEATURE_PATTERNS.`);
+}
+
+// ============================================================================
+// Input Builder
+// ============================================================================
+
+export async function buildVideoInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<VideoGenerationInput | null> {
+  const photos = await extractPhotosFromWizardData(wizardData);
+  if (!photos || photos.length < 1) return null;
+
+  if (!scenario.aiPrompt?.trim()) {
+    throw new Error(`Scenario "${scenario.id}" must have aiPrompt field`);
+  }
+
+  return {
+    sourceImageBase64: photos[0],
+    targetImageBase64: photos[1] || photos[0],
+    prompt: scenario.aiPrompt,
+  };
+}
+
+// ============================================================================
+// 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);
+
+  let lastInputRef: VideoGenerationInput | null = null;
+
+  return {
+    execute: async (input: unknown, onProgress) => {
+      const videoInput = input as VideoGenerationInput;
+      lastInputRef = videoInput;
+
+      const result = await executeVideoFeature(
+        videoFeatureType,
+        {
+          sourceImageBase64: videoInput.sourceImageBase64,
+          targetImageBase64: videoInput.targetImageBase64,
+          prompt: videoInput.prompt,
+        },
+        { onProgress },
+      );
+
+      if (!result.success || !result.videoUrl) {
+        throw new Error(result.error || "Video generation failed");
+      }
+
+      return { videoUrl: result.videoUrl };
+    },
+
+    getCreditCost: () => 1,
+
+    save: async (result: unknown, uid) => {
+      const input = lastInputRef;
+      const videoResult = result as { videoUrl?: string };
+      if (!input || !scenario?.id || !videoResult.videoUrl) return;
+
+      const creation = {
+        id: `${scenario.id}_${Date.now()}`,
+        uri: videoResult.videoUrl,
+        type: scenario.id,
+        prompt: input.prompt,
+        createdAt: new Date(),
+        isShared: false,
+        isFavorite: false,
+        metadata: {
+          scenarioId: scenario.id,
+          scenarioTitle: scenario.title || scenario.id,
+        },
+        output: { videoUrl: videoResult.videoUrl },
+      };
+
+      await repository.create(uid, creation);
+    },
+  };
+}

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

@@ -1,469 +1,54 @@
 /**
  * Wizard Strategy Factory
- * Creates generation strategies for wizard-based scenarios
- * Centralized strategy creation for all wizard flows
+ * Routes to correct strategy based on output type
+ * Single Responsibility: Only dispatches, doesn't contain business logic
  */
 
-import { readFileAsBase64 } from "@umituz/react-native-design-system";
-import type { GenerationStrategy } from "../../../../../presentation/hooks/generation/types";
-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 {
-  GENERATION_TIMEOUT_MS,
-  BASE64_IMAGE_PREFIX,
-  PHOTO_KEY_PREFIX,
-  DEFAULT_STYLE_VALUE,
-  MODEL_INPUT_DEFAULTS,
-  VIDEO_FEATURE_PATTERNS,
-} from "./wizard-strategy.constants";
-
-declare const __DEV__: boolean;
+import type { WizardStrategy } from "./wizard-strategy.types";
+import { createImageStrategy, buildImageInput } from "./image-generation.strategy";
+import { createVideoStrategy, buildVideoInput } from "./video-generation.strategy";
 
 // ============================================================================
 // Types
 // ============================================================================
 
-interface ImageGenerationInput {
-  readonly photos: readonly string[]; // Dynamic array - supports 1, 2, 3... N photos
-  readonly prompt: string;
-}
-
-interface VideoGenerationInput {
-  readonly sourceImageBase64: string;
-  readonly targetImageBase64: string;
-  readonly prompt: string;
-}
-
-type WizardGenerationInput = ImageGenerationInput | VideoGenerationInput;
-type WizardGenerationResult = { imageUrl: string } | { videoUrl: string };
-
-// ============================================================================
-// Image Generation Executor
-// ============================================================================
-
-async function executeImageGeneration(
-  input: ImageGenerationInput,
-  model: string,
-  onProgress?: (progress: number) => void,
-): Promise<{ success: boolean; imageUrl?: string; error?: string }> {
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[WizardStrategy] executeImageGeneration ENTRY", {
-      receivedModel: model,
-      photoCount: input.photos.length,
-      promptLength: input.prompt.length,
-    });
-  }
-
-  const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
-
-  const provider = providerRegistry.getActiveProvider();
-  if (!provider || !provider.isInitialized()) {
-    return { success: false, error: "AI provider not initialized" };
-  }
-
-  try {
-    const formatBase64 = (base64: string): string => {
-      return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
-    };
-
-    const imageUrls = input.photos.map(formatBase64);
-
-    if (imageUrls.length === 0) {
-      return { success: false, error: "At least one image required" };
-    }
-
-    const enhancedPrompt = `Create a photorealistic image featuring the exact two people from the provided photos. Use the person from @image1 and the person from @image2 exactly as they appear in the reference images - maintain their facial features, expressions, and identity. ${input.prompt}. Professional photography, high quality, detailed, natural lighting, photorealistic rendering.`;
-
-    const modelInput = {
-      image_urls: imageUrls,
-      prompt: enhancedPrompt,
-      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 (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[WizardStrategy] ABOUT TO CALL provider.subscribe", {
-        model,
-        modelType: typeof model,
-        modelLength: model?.length,
-        imageUrlsCount: imageUrls.length,
-      });
-    }
-
-    let lastStatus = "";
-    const result = await provider.subscribe(model, modelInput, {
-      timeoutMs: GENERATION_TIMEOUT_MS,
-      onQueueUpdate: (status) => {
-        if (status.status === lastStatus) return;
-        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);
-
-    if (!imageUrl) {
-      return { success: false, error: "No image generated" };
-    }
-
-    return { success: true, imageUrl };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Generation failed";
-    return { success: false, error: message };
-  }
-}
-
-// ============================================================================
-// Photo Extraction (Generic - used by both image and video)
-// ============================================================================
-
-async function extractPhotosFromWizardData(
-  wizardData: Record<string, unknown>,
-): Promise<string[] | null> {
-  // Find ALL photo keys dynamically (photo_1, photo_2, photo_3, ...)
-  const photoKeys = Object.keys(wizardData)
-    .filter((k) => k.includes(PHOTO_KEY_PREFIX))
-    .sort(); // Sort to maintain order (photo_1, photo_2, ...)
-
-  if (photoKeys.length === 0) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] No photos found in wizard data", {
-        keys: Object.keys(wizardData),
-      });
-    }
-    return null;
-  }
-
-  // Extract photo URIs
-  const photoUris: string[] = [];
-  for (const key of photoKeys) {
-    const photo = wizardData[key] as { uri?: string; base64?: string };
-    if (!photo?.uri) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[WizardStrategy] Photo missing URI", { key });
-      }
-      return null;
-    }
-    photoUris.push(photo.uri);
-  }
-
-  // Convert all images to base64 in parallel
-  const photosBase64 = await Promise.all(
-    photoUris.map((uri) => readFileAsBase64(uri)),
-  );
-
-  // Filter out nulls/undefined
-  const validPhotos = photosBase64.filter(Boolean) as string[];
-
-  if (validPhotos.length === 0) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] Failed to convert any images to base64");
-    }
-    return null;
-  }
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[WizardStrategy] Photos extracted", {
-      photoCount: validPhotos.length,
-      photoKeys,
-    });
-  }
-
-  return validPhotos;
-}
-
-// ============================================================================
-// Image Generation Input Builder
-// ============================================================================
-
-async function buildImageGenerationInput(
-  wizardData: Record<string, unknown>,
-  scenario: WizardScenarioData,
-): Promise<ImageGenerationInput | null> {
-  // Extract photos
-  const photos = await extractPhotosFromWizardData(wizardData);
-  if (!photos) return null;
-
-  // Validate scenario prompt
-  if (!scenario.aiPrompt || scenario.aiPrompt.trim() === "") {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] scenario.aiPrompt missing", {
-        scenarioId: scenario.id,
-      });
-    }
-    throw new Error(`Scenario "${scenario.id}" must have aiPrompt field`);
-  }
-
-  let prompt = scenario.aiPrompt;
-
-  // Enhance prompt with style selections (image-specific)
-  const styleEnhancements: string[] = [];
-
-  // Romantic mood (multi-select array)
-  const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
-  if (romanticMoods && romanticMoods.length > 0) {
-    styleEnhancements.push(`Mood: ${romanticMoods.join(", ")}`);
-  }
-
-  // Art style (single select)
-  const artStyle = wizardData.selection_art_style as string | undefined;
-  if (artStyle && artStyle !== DEFAULT_STYLE_VALUE) {
-    styleEnhancements.push(`Art style: ${artStyle}`);
-  }
-
-  // Artist style (single select)
-  const artist = wizardData.selection_artist_style as string | undefined;
-  if (artist && artist !== DEFAULT_STYLE_VALUE) {
-    styleEnhancements.push(`Artist style: ${artist}`);
-  }
-
-  // Enhance prompt with selected styles
-  if (styleEnhancements.length > 0) {
-    prompt = `${prompt}. ${styleEnhancements.join(", ")}`;
-  }
+export type { WizardStrategy } from "./wizard-strategy.types";
 
-  return {
-    photos, // Dynamic array - supports 1, 2, 3... N photos
-    prompt,
-  };
+export interface CreateWizardStrategyOptions {
+  readonly scenario: WizardScenarioData;
+  readonly wizardData: Record<string, unknown>;
+  readonly collectionName?: string;
 }
 
 // ============================================================================
-// Video Generation Input Builder
+// Strategy Factory
 // ============================================================================
 
-async function buildVideoGenerationInput(
-  wizardData: Record<string, unknown>,
-  scenario: WizardScenarioData,
-): Promise<VideoGenerationInput | null> {
-  // Extract photos
-  const photos = await extractPhotosFromWizardData(wizardData);
-  if (!photos) return null;
-
-  // Video requires at least 1 photo (can duplicate if only 1)
-  if (photos.length < 1) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] Video generation needs at least 1 photo");
-    }
-    return null;
-  }
+export function createWizardStrategy(options: CreateWizardStrategyOptions): WizardStrategy {
+  const { scenario, collectionName } = options;
+  const outputType = scenario.outputType || "video";
 
-  // Validate scenario prompt
-  if (!scenario.aiPrompt || scenario.aiPrompt.trim() === "") {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] scenario.aiPrompt missing", {
-        scenarioId: scenario.id,
-      });
-    }
-    throw new Error(`Scenario "${scenario.id}" must have aiPrompt field`);
+  if (outputType === "image") {
+    return createImageStrategy({ scenario, collectionName });
   }
 
-  return {
-    sourceImageBase64: photos[0],
-    targetImageBase64: photos[1] || photos[0], // Use first photo if only 1 provided
-    prompt: scenario.aiPrompt,
-  };
+  return createVideoStrategy({ scenario, collectionName });
 }
 
 // ============================================================================
-// Input Builder Dispatcher (Routes to correct builder)
+// Input Builder
 // ============================================================================
 
-async function buildGenerationInput(
+export async function buildWizardInput(
   wizardData: Record<string, unknown>,
   scenario: WizardScenarioData,
-): Promise<WizardGenerationInput | null> {
+): Promise<unknown> {
   const outputType = scenario.outputType || "video";
 
   if (outputType === "image") {
-    return buildImageGenerationInput(wizardData, scenario);
-  } else {
-    return buildVideoGenerationInput(wizardData, scenario);
-  }
-}
-
-// ============================================================================
-// 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;
-    }
+    return buildImageInput(wizardData, scenario);
   }
 
-  throw new Error(`Unknown video feature type for scenario "${scenarioId}". Add pattern to VIDEO_FEATURE_PATTERNS.`);
-}
-
-// ============================================================================
-// Strategy Factory
-// ============================================================================
-
-export interface CreateWizardStrategyOptions {
-  readonly scenario: WizardScenarioData;
-  readonly wizardData: Record<string, unknown>;
-  readonly collectionName?: string;
+  return buildVideoInput(wizardData, scenario);
 }
-
-export const createWizardStrategy = (
-  options: CreateWizardStrategyOptions,
-): GenerationStrategy<WizardGenerationInput, WizardGenerationResult> => {
-  const { scenario, collectionName = "creations" } = options;
-  const repository = createCreationsRepository(collectionName);
-  const outputType = scenario.outputType || "video";
-  const videoFeatureType = outputType === "video" ? getVideoFeatureType(scenario.id) : null;
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[WizardStrategy] createWizardStrategy called", {
-      scenarioId: scenario.id,
-      scenarioModel: scenario.model,
-      outputType,
-      hasModel: !!scenario.model,
-    });
-  }
-
-  let lastInputRef: WizardGenerationInput | null = null;
-
-  return {
-    execute: async (input, onProgress) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardStrategy] execute() called", {
-          scenarioId: scenario.id,
-          outputType,
-          scenarioModel: scenario.model,
-          hasModel: !!scenario.model,
-        });
-      }
-
-      lastInputRef = input;
-
-      // Execute based on output type
-      if (outputType === "image") {
-        // Validate model is provided by app
-        if (!scenario.model) {
-          throw new Error("Model is required for image generation. Please configure model in app generation.config.ts");
-        }
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[WizardStrategy] About to call executeImageGeneration", {
-            model: scenario.model,
-            scenarioId: scenario.id,
-          });
-        }
-
-        const imageInput = input as ImageGenerationInput;
-        const result = await executeImageGeneration(imageInput, scenario.model, onProgress);
-
-        if (!result.success || !result.imageUrl) {
-          throw new Error(result.error || "Image generation failed");
-        }
-
-        return { imageUrl: result.imageUrl };
-      } else {
-        if (!videoFeatureType) {
-          throw new Error("Video feature type is required for video generation");
-        }
-        const videoInput = input as VideoGenerationInput;
-        const result = await executeVideoFeature(
-          videoFeatureType,
-          {
-            sourceImageBase64: videoInput.sourceImageBase64,
-            targetImageBase64: videoInput.targetImageBase64,
-            prompt: videoInput.prompt,
-          },
-          { onProgress },
-        );
-
-        if (!result.success || !result.videoUrl) {
-          throw new Error(result.error || "Video generation failed");
-        }
-
-        return { videoUrl: result.videoUrl };
-      }
-    },
-
-    getCreditCost: () => 1,
-
-    save: async (result, uid) => {
-      const input = lastInputRef;
-      if (!input) return;
-
-      // Validate scenario
-      if (!scenario || !scenario.id) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[WizardStrategy] Cannot save: scenario.id is undefined");
-        }
-        throw new Error("Scenario ID is required for saving creation");
-      }
-
-      // Extract prompt
-      const prompt = 'prompt' in input ? input.prompt : '';
-
-      // Extract URLs based on output type
-      let mainUri = '';
-      let imageUrl: string | undefined;
-      let videoUrl: string | undefined;
-
-      if (outputType === "image") {
-        const imageResult = result as { imageUrl?: string };
-        imageUrl = imageResult.imageUrl;
-        mainUri = imageUrl || '';
-      } else {
-        const videoResult = result as { videoUrl?: string };
-        videoUrl = videoResult.videoUrl;
-        mainUri = videoUrl || '';
-      }
-
-      // Create unique ID
-      const creationId = `${scenario.id}_${Date.now()}`;
-
-      // Build creation object
-      const creation = {
-        id: creationId,
-        uri: mainUri,
-        type: scenario.id,
-        prompt,
-        createdAt: new Date(),
-        isShared: false,
-        isFavorite: false,
-        metadata: {
-          scenarioId: scenario.id,
-          scenarioTitle: scenario.title || scenario.id,
-        },
-        output: outputType === "image"
-          ? { imageUrl }
-          : { videoUrl },
-      };
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardStrategy] Saving creation", {
-          creationId,
-          scenarioId: scenario.id,
-          outputType,
-        });
-      }
-
-      await repository.create(uid, creation);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardStrategy] Creation saved successfully");
-      }
-    },
-  };
-};
-
-// ============================================================================
-// Input Builder Helper (Public API)
-// ============================================================================
-
-export const buildWizardInput = buildGenerationInput;

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

@@ -0,0 +1,13 @@
+/**
+ * Wizard Strategy Types
+ * Shared types for all wizard strategies
+ */
+
+export interface WizardStrategy {
+  execute: (
+    input: unknown,
+    onProgress?: (progress: number) => void,
+  ) => Promise<{ imageUrl?: string; videoUrl?: string }>;
+  getCreditCost: () => number;
+  save?: (result: unknown, userId: string) => Promise<void>;
+}