@umituz/react-native-ai-generation-content 1.25.20 → 1.25.23

package/package.json

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

package/src/domains/scenarios/configs/wizard-configs.ts

@@ -298,21 +298,61 @@ const mergeConfigOverrides = (
   };
 };
 
+/**
+ * Apply configuration options to filter/modify steps
+ */
+const applyConfigOptions = (
+  config: WizardFeatureConfig,
+  options?: WizardConfigOptions,
+): WizardFeatureConfig => {
+  if (!options) return config;
+
+  let steps = [...config.steps];
+
+  // Filter out style selection steps if disabled
+  if (options.disableStyleSelections) {
+    const styleStepIds = ["romantic_mood", "art_style", "artist_style"];
+    steps = steps.filter((step) => !styleStepIds.includes(step.id));
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[WizardConfig] Style selections disabled", {
+        filteredStepIds: styleStepIds,
+        remainingSteps: steps.map((s) => s.id),
+      });
+    }
+  }
+
+  return {
+    ...config,
+    steps,
+  };
+};
+
+/**
+ * Configuration Options for Wizard Behavior
+ */
+export interface WizardConfigOptions {
+  readonly disableStyleSelections?: boolean; // Disable romantic mood, art style, artist style
+}
+
 /**
  * Get wizard config for a scenario
  * 1. Check for explicit config in SCENARIO_WIZARD_CONFIGS
  * 2. Auto-detect feature type and generate config
  * 3. Apply overrides if provided
+ * 4. Apply options to disable certain steps
  *
  * This means ALL scenarios work automatically!
  */
 export const getScenarioWizardConfig = (
   scenarioId: string,
+  options?: WizardConfigOptions,
   overrides?: Partial<WizardFeatureConfig>,
 ): WizardFeatureConfig => {
   // 1. Explicit config (highest priority)
   if (SCENARIO_WIZARD_CONFIGS[scenarioId]) {
-    return mergeConfigOverrides(SCENARIO_WIZARD_CONFIGS[scenarioId], overrides);
+    const config = mergeConfigOverrides(SCENARIO_WIZARD_CONFIGS[scenarioId], overrides);
+    return applyConfigOptions(config, options);
   }
 
   // 2. Auto-detect feature type
@@ -330,7 +370,10 @@ export const getScenarioWizardConfig = (
   const config = factory(scenarioId);
 
   // 4. Apply overrides
-  return mergeConfigOverrides(config, overrides);
+  const configWithOverrides = mergeConfigOverrides(config, overrides);
+
+  // 5. Apply options (disable steps)
+  return applyConfigOptions(configWithOverrides, options);
 };
 
 /**

package/src/domains/scenarios/index.ts

@@ -23,3 +23,5 @@ export {
   hasExplicitConfig,
   getScenarioFeatureType,
 } from "./configs/wizard-configs";
+
+export type { WizardConfigOptions } from "./configs/wizard-configs";

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

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

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

@@ -0,0 +1,358 @@
+/**
+ * Wizard Strategy Factory
+ * Creates generation strategies for wizard-based scenarios
+ * Centralized strategy creation for all wizard flows
+ */
+
+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 { enhanceCouplePrompt } from "../../../../features/couple-future/infrastructure/couplePromptEnhancer";
+import type { CoupleFeatureSelection } from "../../../../features/couple-future/domain/types";
+import type { WizardOutputType, WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+
+declare const __DEV__: boolean;
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface ImageGenerationInput {
+  readonly partnerABase64: string;
+  readonly partnerBBase64: string;
+  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,
+  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 || !provider.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  try {
+    onProgress?.(5);
+
+    const formatBase64 = (base64: string): string => {
+      return base64.startsWith("data:") ? base64 : `data:image/jpeg;base64,${base64}`;
+    };
+
+    const imageUrls = [input.partnerABase64, input.partnerBBase64]
+      .filter(Boolean)
+      .map(formatBase64);
+
+    if (imageUrls.length < 2) {
+      return { success: false, error: "Two images required" };
+    }
+
+    onProgress?.(10);
+
+    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: "1:1",
+      output_format: "jpeg",
+      num_images: 1,
+      enable_safety_checker: false,
+    };
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[WizardStrategy] Starting image generation");
+    }
+
+    let lastStatus = "";
+    const result = await provider.subscribe("fal-ai/nano-banana", modelInput, {
+      timeoutMs: 120000,
+      onQueueUpdate: (status) => {
+        if (status.status === lastStatus) return;
+        lastStatus = status.status;
+        if (status.status === "IN_QUEUE") onProgress?.(20);
+        else if (status.status === "IN_PROGRESS") onProgress?.(50);
+      },
+    });
+
+    onProgress?.(90);
+
+    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 };
+  }
+}
+
+// ============================================================================
+// Input Builder
+// ============================================================================
+
+async function buildGenerationInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<WizardGenerationInput | null> {
+  const photo1Key = Object.keys(wizardData).find((k) => k.includes("photo_1"));
+  const photo2Key = Object.keys(wizardData).find((k) => k.includes("photo_2"));
+
+  if (!photo1Key || !photo2Key) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[WizardStrategy] Missing photos in wizard data", {
+        keys: Object.keys(wizardData),
+        hasPhoto1: !!photo1Key,
+        hasPhoto2: !!photo2Key,
+      });
+    }
+    return null;
+  }
+
+  const photo1 = wizardData[photo1Key] as { uri?: string; base64?: string };
+  const photo2 = wizardData[photo2Key] as { uri?: string; base64?: string };
+
+  if (!photo1?.uri || !photo2?.uri) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[WizardStrategy] Photos missing URI", {
+        photo1HasUri: !!photo1?.uri,
+        photo2HasUri: !!photo2?.uri,
+      });
+    }
+    return null;
+  }
+
+  // Convert images to base64
+  const [photo1Base64, photo2Base64] = await Promise.all([
+    readFileAsBase64(photo1.uri),
+    readFileAsBase64(photo2.uri),
+  ]);
+
+  if (!photo1Base64 || !photo2Base64) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[WizardStrategy] Failed to convert images to base64");
+    }
+    return null;
+  }
+
+  let prompt = scenario.aiPrompt || `Generate ${scenario.id} scene`;
+  const outputType = scenario.outputType || "video";
+
+  // For image generation, enhance prompt with style selections
+  if (outputType === "image") {
+    const selections: CoupleFeatureSelection = {};
+
+    // Romantic mood (multi-select array)
+    const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
+    if (romanticMoods && romanticMoods.length > 0) {
+      selections.romanticMoods = romanticMoods;
+    }
+
+    // Art style (single select)
+    const artStyle = wizardData.selection_art_style as string | undefined;
+    if (artStyle && artStyle !== "original") {
+      selections.artStyle = artStyle;
+    }
+
+    // Artist style (single select)
+    const artist = wizardData.selection_artist_style as string | undefined;
+    if (artist && artist !== "original") {
+      selections.artist = artist;
+    }
+
+    // Enhance prompt with selected styles
+    if (Object.keys(selections).length > 0) {
+      prompt = enhanceCouplePrompt(prompt, selections);
+    }
+
+    return {
+      partnerABase64: photo1Base64,
+      partnerBBase64: photo2Base64,
+      prompt,
+    } as ImageGenerationInput;
+  } else {
+    return {
+      sourceImageBase64: photo1Base64,
+      targetImageBase64: photo2Base64,
+      prompt,
+    } as VideoGenerationInput;
+  }
+}
+
+// ============================================================================
+// Video Feature Type Detection
+// ============================================================================
+
+function getVideoFeatureType(scenarioId: string): VideoFeatureType {
+  const id = scenarioId.toLowerCase();
+
+  if (id.includes("kiss")) return "ai-kiss";
+  if (id.includes("hug")) return "ai-hug";
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.warn(`[WizardStrategy] Unknown scenario type "${scenarioId}", defaulting to ai-hug`);
+  }
+  return "ai-hug";
+}
+
+// ============================================================================
+// Strategy Factory
+// ============================================================================
+
+export interface CreateWizardStrategyOptions {
+  readonly scenario: WizardScenarioData;
+  readonly wizardData: Record<string, unknown>;
+  readonly collectionName?: string;
+}
+
+export const createWizardStrategy = (
+  options: CreateWizardStrategyOptions,
+): GenerationStrategy<WizardGenerationInput, WizardGenerationResult> => {
+  const { scenario, wizardData, collectionName = "creations" } = options;
+  const repository = createCreationsRepository(collectionName);
+  const outputType = scenario.outputType || "video";
+  const videoFeatureType = getVideoFeatureType(scenario.id);
+
+  let lastInputRef: WizardGenerationInput | null = null;
+
+  return {
+    execute: async (input, onProgress) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[WizardStrategy] Executing generation", {
+          scenarioId: scenario.id,
+          outputType,
+        });
+      }
+
+      lastInputRef = input;
+
+      // Execute based on output type
+      if (outputType === "image") {
+        const imageInput = input as ImageGenerationInput;
+        const result = await executeImageGeneration(imageInput, onProgress);
+
+        if (!result.success || !result.imageUrl) {
+          throw new Error(result.error || "Image generation failed");
+        }
+
+        return { imageUrl: result.imageUrl };
+      } else {
+        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: {
+          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/wizard/presentation/components/GenericWizardFlow.tsx

@@ -22,7 +22,7 @@ import { renderStep } from "../../infrastructure/renderers/step-renderer";
 import type { WizardFeatureConfig } from "../../domain/entities/wizard-config.types";
 import { buildFlowStepsFromWizard } from "../../infrastructure/builders/dynamic-step-builder";
 import { useWizardGeneration, type WizardScenarioData } from "../hooks/useWizardGeneration";
-import type { AlertMessages } from "../../../../presentation/hooks/generation/orchestrator.types";
+import type { AlertMessages } from "../../../../presentation/hooks/generation/types";
 
 export interface GenericWizardFlowProps {
   readonly featureConfig: WizardFeatureConfig;
@@ -96,9 +96,32 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
     [updateProgress],
   );
 
+  // Ensure scenario has required fields - use feature config as fallback
+  const validatedScenario = useMemo(() => {
+    if (scenario && scenario.id && scenario.aiPrompt !== undefined) {
+      return scenario;
+    }
+
+    // Fallback to feature config
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn("[GenericWizardFlow] Scenario missing required fields, using fallback", {
+        hasScenario: !!scenario,
+        scenarioId: scenario?.id,
+        featureConfigId: featureConfig.id,
+      });
+    }
+
+    return {
+      id: featureConfig.id,
+      aiPrompt: "",
+      outputType: "image" as const, // Default to image for safety
+      title: featureConfig.id,
+    };
+  }, [scenario, featureConfig.id]);
+
   // Generation hook - handles AI generation automatically
   const generationHook = useWizardGeneration({
-    scenario: scenario || { id: featureConfig.id, aiPrompt: "" },
+    scenario: validatedScenario,
     wizardData: customData,
     userId,
     isGeneratingStep: currentStep?.type === StepType.GENERATING,
@@ -110,7 +133,7 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
   });
 
   // Track previous step ID to prevent infinite loops
-  const prevStepIdRef = useRef<string>();
+  const prevStepIdRef = useRef<string | undefined>(undefined);
 
   // DEBUG logging
   if (typeof __DEV__ !== "undefined" && __DEV__) {

package/src/domains/wizard/presentation/hooks/useWizardGeneration.ts

@@ -1,49 +1,30 @@
 /**
  * useWizardGeneration Hook
- * Generic generation hook for ANY wizard-based scenario
- * Handles video generation for couple features (ai-hug, ai-kiss, etc.)
+ * Wizard generation using orchestrator + strategy factory pattern
  */
 
-import { useEffect, useRef, useMemo, useCallback } from "react";
-import { readFileAsBase64 } from "@umituz/react-native-design-system";
-import {
-  useGenerationOrchestrator,
-  type GenerationStrategy,
-} from "../../../../presentation/hooks/generation";
-import { executeVideoFeature } from "../../../../infrastructure/services/video-feature-executor.service";
-import { createCreationsRepository } from "../../../../domains/creations/infrastructure/adapters";
-import type { VideoFeatureType } from "../../../../domain/interfaces";
-import type { AlertMessages } from "../../../../presentation/hooks/generation/orchestrator.types";
-import { enhanceCouplePrompt } from "../../../../features/couple-future/infrastructure/couplePromptEnhancer";
-import type { CoupleFeatureSelection } from "../../../../features/couple-future/domain/types";
+import { useEffect, useRef, useMemo } from "react";
+import { useGenerationOrchestrator } from "../../../../presentation/hooks/generation";
+import type { AlertMessages } from "../../../../presentation/hooks/generation/types";
+import { createWizardStrategy, buildWizardInput } from "../../infrastructure/strategies";
 
 declare const __DEV__: boolean;
 
+// ============================================================================
+// Types
+// ============================================================================
+
 export type WizardOutputType = "image" | "video";
 
 export interface WizardScenarioData {
   readonly id: string;
   readonly aiPrompt: string;
-  readonly outputType?: WizardOutputType; // "image" for couple-future, "video" for ai-hug/kiss
+  readonly outputType?: WizardOutputType;
   readonly title?: string;
   readonly description?: string;
   [key: string]: unknown;
 }
 
-interface VideoGenerationInput {
-  readonly sourceImageBase64: string;
-  readonly targetImageBase64: string;
-  readonly prompt: string;
-}
-
-interface ImageGenerationInput {
-  readonly partnerABase64: string;
-  readonly partnerBBase64: string;
-  readonly prompt: string;
-}
-
-type GenerationInput = VideoGenerationInput | ImageGenerationInput;
-
 export interface UseWizardGenerationProps {
   readonly scenario: WizardScenarioData;
   readonly wizardData: Record<string, unknown>;
@@ -61,183 +42,9 @@ export interface UseWizardGenerationReturn {
   readonly progress: number;
 }
 
-function getVideoFeatureType(scenarioId: string): VideoFeatureType {
-  const id = scenarioId.toLowerCase();
-
-  if (id.includes("kiss")) return "ai-kiss";
-  if (id.includes("hug")) return "ai-hug";
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.warn(`[useWizardGeneration] Unknown scenario type "${scenarioId}", defaulting to ai-hug`);
-  }
-  return "ai-hug";
-}
-
-async function executeImageGeneration(
-  input: ImageGenerationInput,
-  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 || !provider.isInitialized()) {
-    return { success: false, error: "AI provider not initialized" };
-  }
-
-  try {
-    onProgress?.(5);
-
-    const formatBase64 = (base64: string): string => {
-      return base64.startsWith("data:") ? base64 : `data:image/jpeg;base64,${base64}`;
-    };
-
-    const imageUrls = [input.partnerABase64, input.partnerBBase64]
-      .filter(Boolean)
-      .map(formatBase64);
-
-    if (imageUrls.length < 2) {
-      return { success: false, error: "Two images required" };
-    }
-
-    onProgress?.(10);
-
-    const enhancedPrompt = `A photorealistic image of a couple. The first person @image1 and the second person @image2. ${input.prompt}. High quality, detailed, professional photography.`;
-
-    const modelInput = {
-      image_urls: imageUrls,
-      prompt: enhancedPrompt,
-      aspect_ratio: "1:1",
-      output_format: "jpeg",
-      num_images: 1,
-    };
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[useWizardGeneration] Starting image generation");
-    }
-
-    let lastStatus = "";
-    const result = await provider.subscribe("fal-ai/nano-banana", modelInput, {
-      timeoutMs: 120000,
-      onQueueUpdate: (status) => {
-        if (status.status === lastStatus) return;
-        lastStatus = status.status;
-        if (status.status === "IN_QUEUE") onProgress?.(20);
-        else if (status.status === "IN_PROGRESS") onProgress?.(50);
-      },
-    });
-
-    onProgress?.(90);
-
-    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 };
-  }
-}
-
-
-async function buildGenerationInput(
-  wizardData: Record<string, unknown>,
-  scenario: WizardScenarioData,
-): Promise<GenerationInput | null> {
-  const photo1Key = Object.keys(wizardData).find((k) => k.includes("photo_1"));
-  const photo2Key = Object.keys(wizardData).find((k) => k.includes("photo_2"));
-
-  if (!photo1Key || !photo2Key) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[useWizardGeneration] Missing photos in wizard data", {
-        keys: Object.keys(wizardData),
-        hasPhoto1: !!photo1Key,
-        hasPhoto2: !!photo2Key,
-      });
-    }
-    return null;
-  }
-
-  const photo1 = wizardData[photo1Key] as { uri?: string; base64?: string };
-  const photo2 = wizardData[photo2Key] as { uri?: string; base64?: string };
-
-  if (!photo1?.uri || !photo2?.uri) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[useWizardGeneration] Photos missing URI", {
-        photo1HasUri: !!photo1?.uri,
-        photo2HasUri: !!photo2?.uri,
-      });
-    }
-    return null;
-  }
-
-  // Convert images to base64 using design system utility
-  const [photo1Base64, photo2Base64] = await Promise.all([
-    readFileAsBase64(photo1.uri),
-    readFileAsBase64(photo2.uri),
-  ]);
-
-  // Validate base64 conversion results
-  if (!photo1Base64 || !photo2Base64) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[useWizardGeneration] Failed to convert images to base64", {
-        photo1Success: !!photo1Base64,
-        photo2Success: !!photo2Base64,
-      });
-    }
-    return null;
-  }
-
-  let prompt = scenario.aiPrompt || `Generate ${scenario.id} scene`;
-  const outputType = scenario.outputType || "video"; // Default to video for backward compatibility
-
-  // For image generation, enhance prompt with style selections
-  if (outputType === "image") {
-    // Extract style selections from wizard data
-    const selections: CoupleFeatureSelection = {};
-
-    // Romantic mood (multi-select array)
-    const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
-    if (romanticMoods && romanticMoods.length > 0) {
-      selections.romanticMoods = romanticMoods;
-    }
-
-    // Art style (single select)
-    const artStyle = wizardData.selection_art_style as string | undefined;
-    if (artStyle && artStyle !== "original") {
-      selections.artStyle = artStyle;
-    }
-
-    // Artist style (single select)
-    const artist = wizardData.selection_artist_style as string | undefined;
-    if (artist && artist !== "original") {
-      selections.artist = artist;
-    }
-
-    // Enhance prompt with selected styles (only if not "original")
-    if (Object.keys(selections).length > 0) {
-      prompt = enhanceCouplePrompt(prompt, selections);
-    }
-
-    return {
-      partnerABase64: photo1Base64,
-      partnerBBase64: photo2Base64,
-      prompt,
-    } as ImageGenerationInput;
-  } else {
-    return {
-      sourceImageBase64: photo1Base64,
-      targetImageBase64: photo2Base64,
-      prompt,
-    } as VideoGenerationInput;
-  }
-}
+// ============================================================================
+// Hook
+// ============================================================================
 
 export const useWizardGeneration = (
   props: UseWizardGenerationProps,
@@ -255,119 +62,63 @@ export const useWizardGeneration = (
   } = props;
 
   const hasStarted = useRef(false);
-  const lastInputRef = useRef<GenerationInput | null>(null);
-  const repository = useMemo(() => createCreationsRepository("creations"), []);
-  const videoFeatureType = useMemo(() => getVideoFeatureType(scenario.id), [scenario.id]);
-  const outputType = scenario.outputType || "video";
-
-  type GenerationResult = { videoUrl: string } | { imageUrl: string };
-
-  const strategy: GenerationStrategy<GenerationInput, GenerationResult> = useMemo(
-    () => ({
-      execute: async (input, onProgress) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[useWizardGeneration] Executing generation", {
-            scenarioId: scenario.id,
-            outputType,
-          });
-        }
-
-        lastInputRef.current = input;
-
-        // Execute based on output type
-        if (outputType === "image") {
-          const imageInput = input as ImageGenerationInput;
-          const result = await executeImageGeneration(imageInput, onProgress);
-
-          if (!result.success || !result.imageUrl) {
-            throw new Error(result.error || "Image generation failed");
-          }
-
-          return { imageUrl: result.imageUrl };
-        } else {
-          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.current;
-        if (!input) return;
-
-        // Both input types have prompt field
-        const prompt = 'prompt' in input ? input.prompt : '';
-
-        // Build creation object with only the relevant URL field
-        const creation: any = {
-          scenarioId: scenario.id,
-          scenarioTitle: scenario.title || scenario.id,
-          prompt,
-          createdAt: Date.now(),
-        };
-
-        // Add only the relevant URL based on output type
-        if (outputType === "image") {
-          const imageResult = result as { imageUrl?: string };
-          creation.imageUrl = imageResult.imageUrl;
-        } else {
-          const videoResult = result as { videoUrl?: string };
-          creation.videoUrl = videoResult.videoUrl;
-        }
 
-        await repository.create(uid, creation);
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[useWizardGeneration] Creation saved");
-        }
+  // Log output type on mount
+  useEffect(() => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useWizardGeneration] Initialized", {
+        scenarioId: scenario.id,
+        outputType: scenario.outputType || "video",
+        hasOutputType: !!scenario.outputType,
+      });
+    }
+  }, [scenario.id, scenario.outputType]);
+
+  // Create strategy using factory
+  const strategy = useMemo(() => {
+    return createWizardStrategy({
+      scenario,
+      wizardData,
+      collectionName: "creations",
+    });
+  }, [scenario, wizardData]);
+
+  // Use orchestrator with strategy
+  const { generate, isGenerating, progress } = useGenerationOrchestrator(
+    strategy,
+    {
+      userId,
+      alertMessages: alertMessages || {
+        networkError: "No internet connection",
+        policyViolation: "Content policy violation",
+        saveFailed: "Failed to save",
+        creditFailed: "Failed to deduct credits",
+        unknown: "An error occurred",
       },
-    }),
-    [scenario, videoFeatureType, repository, outputType],
-  );
-
-  const { generate, isGenerating, progress } = useGenerationOrchestrator(strategy, {
-    userId,
-    alertMessages,
-    onCreditsExhausted,
-    onSuccess: useCallback(
-      (result) => {
+      onCreditsExhausted,
+      onSuccess: (result) => {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[useWizardGeneration] Success");
         }
         onSuccess?.(result);
       },
-      [onSuccess],
-    ),
-    onError: useCallback(
-      (err) => {
+      onError: (err) => {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[useWizardGeneration] Error:", err.message);
         }
         onError?.(err.message);
       },
-      [onError],
-    ),
-  });
+    },
+  );
 
+  // Sync progress to parent
   useEffect(() => {
     if (onProgressChange) {
       onProgressChange(progress);
     }
   }, [progress, onProgressChange]);
 
+  // Auto-start generation when entering generating step
   useEffect(() => {
     if (isGeneratingStep && !hasStarted.current && !isGenerating) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -377,7 +128,8 @@ export const useWizardGeneration = (
         });
       }
 
-      buildGenerationInput(wizardData, scenario)
+      // Build input and start generation
+      buildWizardInput(wizardData, scenario)
         .then((input) => {
           if (!input) {
             const error = "Failed to build generation input";
@@ -399,6 +151,7 @@ export const useWizardGeneration = (
         });
     }
 
+    // Reset hasStarted when leaving generating step
     if (!isGeneratingStep && hasStarted.current) {
       hasStarted.current = false;
     }