@umituz/react-native-ai-generation-content 1.20.14 → 1.20.15

package/package.json

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

package/src/features/couple-future/presentation/hooks/useCoupleFutureFlow.ts

@@ -1,85 +1,29 @@
 /**
  * useCoupleFutureFlow Hook
  * Optimized: Merged flow + generation logic
- * Uses centralized orchestrator directly
+ * Uses centralized orchestrator with lifecycle management
  */
 
-import { useCallback, useEffect, useRef, useMemo } from "react";
-import { InteractionManager } from "react-native";
+import { useEffect, useRef, useMemo } from "react";
 import {
   useGenerationOrchestrator,
   type GenerationStrategy,
-  type AlertMessages,
 } from "../../../../presentation/hooks/generation";
 import { executeCoupleFuture } from "../../infrastructure/executor";
 import { buildGenerationInputFromConfig } from "../../infrastructure/generationUtils";
 import { createCreationsRepository } from "../../../../domains/creations/infrastructure/adapters";
-import type { UploadedImage } from "../../../partner-upload/domain/types";
 import type { CoupleFutureInput } from "../../domain/types";
-import type { Creation } from "../../../../domains/creations/domain/entities/Creation";
+import type { CoupleFutureFlowProps } from "./useCoupleFutureFlow.types";
+import { useCoupleFutureHandlers } from "./useCoupleFutureHandlers";
 
-declare const __DEV__: boolean;
+export type {
+  CoupleFutureFlowConfig,
+  CoupleFutureFlowState,
+  CoupleFutureFlowActions,
+  CoupleFutureFlowProps,
+} from "./useCoupleFutureFlow.types";
 
-export interface CoupleFutureFlowConfig<TStep, TScenarioId> {
-  steps: {
-    SCENARIO: TStep;
-    SCENARIO_PREVIEW: TStep;
-    COUPLE_FEATURE_SELECTOR: TStep;
-    TEXT_INPUT: TStep;
-    PARTNER_A: TStep;
-    PARTNER_B: TStep;
-    GENERATING: TStep;
-  };
-  customScenarioId: TScenarioId;
-}
-
-export interface CoupleFutureFlowState<TStep, TScenarioId> {
-  step: TStep;
-  selectedScenarioId: TScenarioId | null;
-  selectedFeature: string | null;
-  partnerA: unknown;
-  partnerB: unknown;
-  partnerAName: string;
-  partnerBName: string;
-  customPrompt: string | null;
-  visualStyle: string | null;
-  selection: unknown;
-  isProcessing: boolean;
-  scenarioConfig: unknown;
-  selectedScenarioData: { requiresPhoto?: boolean } | null;
-}
-
-export interface CoupleFutureFlowActions<TStep, TScenarioId, TResult> {
-  setStep: (step: TStep) => void;
-  selectScenario: (id: TScenarioId) => void;
-  setPartnerA: (image: unknown) => void;
-  setPartnerAName: (name: string) => void;
-  setPartnerB: (image: unknown) => void;
-  setPartnerBName: (name: string) => void;
-  setCustomPrompt: (prompt: string) => void;
-  setVisualStyle: (style: string) => void;
-  startGeneration: () => void;
-  generationSuccess: (result: TResult) => void;
-  generationError: (error: string) => void;
-  requireFeature: (callback: () => void) => void;
-  onNavigateToHistory: () => void;
-}
-
-export interface CoupleFutureFlowProps<TStep, TScenarioId, TResult> {
-  userId?: string;
-  config: CoupleFutureFlowConfig<TStep, TScenarioId>;
-  state: CoupleFutureFlowState<TStep, TScenarioId>;
-  actions: CoupleFutureFlowActions<TStep, TScenarioId, TResult>;
-  generationConfig: {
-    visualStyleModifiers: Record<string, string>;
-    defaultPartnerAName: string;
-    defaultPartnerBName: string;
-  };
-  alertMessages: AlertMessages;
-  processResult: (imageUrl: string, input: CoupleFutureInput) => TResult;
-  buildCreation: (result: TResult, input: CoupleFutureInput) => Creation | null;
-  onCreditsExhausted: () => void;
-}
+declare const __DEV__: boolean;
 
 export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
   props: CoupleFutureFlowProps<TStep, TScenarioId, TResult>,
@@ -116,37 +60,68 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
     [processResult, buildCreation, repository],
   );
 
-  // Use orchestrator directly
+  // Use orchestrator with centralized lifecycle management
   const { generate, isGenerating, progress } = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
     onCreditsExhausted,
     onSuccess: (result) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[CoupleFutureFlow] 🎉 Success");
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CoupleFutureFlow] 🎉 Success - calling generationSuccess");
+      }
       actions.generationSuccess(result as TResult);
-      InteractionManager.runAfterInteractions(() => setTimeout(() => actions.onNavigateToHistory(), 300));
     },
     onError: (err) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[CoupleFutureFlow] ❌ Error:", err.message);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CoupleFutureFlow] ❌ Error:", err.message);
+      }
       actions.generationError(err.message);
     },
+    // Centralized lifecycle management - navigation handled by orchestrator
+    lifecycle: {
+      onComplete: (status) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[CoupleFutureFlow] 📍 Lifecycle onComplete:", status);
+        }
+        if (status === "success") {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[CoupleFutureFlow] 🚀 Navigating to History");
+          }
+          actions.onNavigateToHistory();
+        }
+      },
+      completeDelay: 500,
+    },
   });
 
   // Trigger generation when step changes to GENERATING
   useEffect(() => {
+    const step = state.step;
+    const isProcessing = state.isProcessing;
+
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CoupleFutureFlow] 📍 Step changed:", {
-        currentStep: state.step,
+      console.log("[CoupleFutureFlow] 📍 Step effect triggered:", {
+        currentStep: step,
         targetStep: config.steps.GENERATING,
-        isProcessing: state.isProcessing,
+        isProcessing,
         hasStarted: hasStarted.current,
       });
     }
-    if (state.step !== config.steps.GENERATING) {
+
+    if (step !== config.steps.GENERATING) {
       hasStarted.current = false;
       return;
     }
-    if (!state.isProcessing || hasStarted.current) return;
+
+    if (!isProcessing || hasStarted.current) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CoupleFutureFlow] ⏭️ Skipping generation:", {
+          reason: !isProcessing ? "not processing" : "already started",
+        });
+      }
+      return;
+    }
+
     hasStarted.current = true;
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -167,87 +142,25 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
       visualStyles: generationConfig.visualStyleModifiers,
       customScenarioId: config.customScenarioId as string,
     });
-    if (input) generate(input);
-  }, [state, config, generationConfig, generate]);
-
-  // Handlers
-  const handleScenarioSelect = useCallback(
-    (id: string) => {
-      actions.selectScenario(id as TScenarioId);
-      actions.setStep(config.steps.SCENARIO_PREVIEW);
-    },
-    [actions, config.steps.SCENARIO_PREVIEW],
-  );
-
-  const handleScenarioPreviewBack = useCallback(() => actions.setStep(config.steps.SCENARIO), [actions, config.steps.SCENARIO]);
-
-  const handleScenarioPreviewContinue = useCallback(() => {
-    if (state.selectedFeature) actions.setStep(config.steps.COUPLE_FEATURE_SELECTOR);
-    else if (state.selectedScenarioId === config.customScenarioId || state.selectedScenarioData?.requiresPhoto === false)
-      actions.setStep(config.steps.TEXT_INPUT);
-    else actions.setStep(config.steps.PARTNER_A);
-  }, [actions, config, state.selectedFeature, state.selectedScenarioId, state.selectedScenarioData]);
-
-  const handlePartnerAContinue = useCallback(
-    (image: UploadedImage, name: string) => {
-      actions.setPartnerA(image);
-      actions.setPartnerAName(name);
-      actions.setStep(config.steps.PARTNER_B);
-    },
-    [actions, config.steps.PARTNER_B],
-  );
 
-  const handlePartnerABack = useCallback(() => {
-    actions.setStep(state.selectedScenarioId === config.customScenarioId ? config.steps.TEXT_INPUT : config.steps.SCENARIO_PREVIEW);
-  }, [actions, config, state.selectedScenarioId]);
-
-  const handlePartnerBContinue = useCallback(
-    (image: UploadedImage, name: string) => {
+    if (input) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] 🎬 handlePartnerBContinue called, invoking requireFeature");
+        console.log("[CoupleFutureFlow] 🚀 Starting generation with input");
       }
-      actions.requireFeature(() => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFutureFlow] 🚀 Pending action executing: setPartnerB, setPartnerBName, startGeneration");
-        }
-        actions.setPartnerB(image);
-        actions.setPartnerBName(name);
-        actions.startGeneration();
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFutureFlow] ✅ startGeneration called successfully");
-        }
-      });
-    },
-    [actions],
-  );
-
-  const handlePartnerBBack = useCallback(() => actions.setStep(config.steps.PARTNER_A), [actions, config.steps.PARTNER_A]);
-
-  const handleMagicPromptContinue = useCallback(
-    (prompt: string, style: string) => {
-      actions.setCustomPrompt(prompt);
-      actions.setVisualStyle(style);
-      if (state.selectedScenarioId === config.customScenarioId) actions.setStep(config.steps.PARTNER_A);
-      else actions.startGeneration();
-    },
-    [actions, config, state.selectedScenarioId],
-  );
+      generate(input);
+    } else {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CoupleFutureFlow] ⚠️ No input built, skipping generation");
+      }
+    }
+  }, [state.step, state.isProcessing, state.partnerA, state.partnerB, state.partnerAName, state.partnerBName, state.scenarioConfig, state.customPrompt, state.visualStyle, state.selection, config.steps.GENERATING, config.customScenarioId, generationConfig, generate]);
 
-  const handleMagicPromptBack = useCallback(() => actions.setStep(config.steps.SCENARIO_PREVIEW), [actions, config.steps.SCENARIO_PREVIEW]);
+  // Use extracted handlers hook
+  const handlers = useCoupleFutureHandlers({ config, state, actions });
 
   return {
     isGenerating,
     progress,
-    handlers: {
-      handleScenarioSelect,
-      handleScenarioPreviewBack,
-      handleScenarioPreviewContinue,
-      handlePartnerAContinue,
-      handlePartnerABack,
-      handlePartnerBContinue,
-      handlePartnerBBack,
-      handleMagicPromptContinue,
-      handleMagicPromptBack,
-    },
+    handlers,
   };
 };

package/src/features/couple-future/presentation/hooks/useCoupleFutureFlow.types.ts

@@ -0,0 +1,69 @@
+/**
+ * useCoupleFutureFlow Types
+ * Type definitions for couple future flow hook
+ */
+
+import type { AlertMessages } from "../../../../presentation/hooks/generation";
+import type { CoupleFutureInput } from "../../domain/types";
+import type { Creation } from "../../../../domains/creations/domain/entities/Creation";
+
+export interface CoupleFutureFlowConfig<TStep, TScenarioId> {
+  steps: {
+    SCENARIO: TStep;
+    SCENARIO_PREVIEW: TStep;
+    COUPLE_FEATURE_SELECTOR: TStep;
+    TEXT_INPUT: TStep;
+    PARTNER_A: TStep;
+    PARTNER_B: TStep;
+    GENERATING: TStep;
+  };
+  customScenarioId: TScenarioId;
+}
+
+export interface CoupleFutureFlowState<TStep, TScenarioId> {
+  step: TStep;
+  selectedScenarioId: TScenarioId | null;
+  selectedFeature: string | null;
+  partnerA: unknown;
+  partnerB: unknown;
+  partnerAName: string;
+  partnerBName: string;
+  customPrompt: string | null;
+  visualStyle: string | null;
+  selection: unknown;
+  isProcessing: boolean;
+  scenarioConfig: unknown;
+  selectedScenarioData: { requiresPhoto?: boolean } | null;
+}
+
+export interface CoupleFutureFlowActions<TStep, TScenarioId, TResult> {
+  setStep: (step: TStep) => void;
+  selectScenario: (id: TScenarioId) => void;
+  setPartnerA: (image: unknown) => void;
+  setPartnerAName: (name: string) => void;
+  setPartnerB: (image: unknown) => void;
+  setPartnerBName: (name: string) => void;
+  setCustomPrompt: (prompt: string) => void;
+  setVisualStyle: (style: string) => void;
+  startGeneration: () => void;
+  generationSuccess: (result: TResult) => void;
+  generationError: (error: string) => void;
+  requireFeature: (callback: () => void) => void;
+  onNavigateToHistory: () => void;
+}
+
+export interface CoupleFutureFlowProps<TStep, TScenarioId, TResult> {
+  userId?: string;
+  config: CoupleFutureFlowConfig<TStep, TScenarioId>;
+  state: CoupleFutureFlowState<TStep, TScenarioId>;
+  actions: CoupleFutureFlowActions<TStep, TScenarioId, TResult>;
+  generationConfig: {
+    visualStyleModifiers: Record<string, string>;
+    defaultPartnerAName: string;
+    defaultPartnerBName: string;
+  };
+  alertMessages: AlertMessages;
+  processResult: (imageUrl: string, input: CoupleFutureInput) => TResult;
+  buildCreation: (result: TResult, input: CoupleFutureInput) => Creation | null;
+  onCreditsExhausted: () => void;
+}

package/src/features/couple-future/presentation/hooks/useCoupleFutureHandlers.ts

@@ -0,0 +1,117 @@
+/**
+ * useCoupleFutureHandlers Hook
+ * Step navigation handlers for couple future flow
+ */
+
+import { useCallback } from "react";
+import type { UploadedImage } from "../../../partner-upload/domain/types";
+import type { CoupleFutureFlowConfig, CoupleFutureFlowState, CoupleFutureFlowActions } from "./useCoupleFutureFlow.types";
+
+declare const __DEV__: boolean;
+
+interface UseCoupleFutureHandlersProps<TStep, TScenarioId, TResult> {
+  config: CoupleFutureFlowConfig<TStep, TScenarioId>;
+  state: CoupleFutureFlowState<TStep, TScenarioId>;
+  actions: CoupleFutureFlowActions<TStep, TScenarioId, TResult>;
+}
+
+export function useCoupleFutureHandlers<TStep, TScenarioId, TResult>(
+  props: UseCoupleFutureHandlersProps<TStep, TScenarioId, TResult>,
+) {
+  const { config, state, actions } = props;
+
+  const handleScenarioSelect = useCallback(
+    (id: string) => {
+      actions.selectScenario(id as TScenarioId);
+      actions.setStep(config.steps.SCENARIO_PREVIEW);
+    },
+    [actions, config.steps.SCENARIO_PREVIEW],
+  );
+
+  const handleScenarioPreviewBack = useCallback(
+    () => actions.setStep(config.steps.SCENARIO),
+    [actions, config.steps.SCENARIO],
+  );
+
+  const handleScenarioPreviewContinue = useCallback(() => {
+    if (state.selectedFeature) {
+      actions.setStep(config.steps.COUPLE_FEATURE_SELECTOR);
+    } else if (
+      state.selectedScenarioId === config.customScenarioId ||
+      state.selectedScenarioData?.requiresPhoto === false
+    ) {
+      actions.setStep(config.steps.TEXT_INPUT);
+    } else {
+      actions.setStep(config.steps.PARTNER_A);
+    }
+  }, [actions, config, state.selectedFeature, state.selectedScenarioId, state.selectedScenarioData]);
+
+  const handlePartnerAContinue = useCallback(
+    (image: UploadedImage, name: string) => {
+      actions.setPartnerA(image);
+      actions.setPartnerAName(name);
+      actions.setStep(config.steps.PARTNER_B);
+    },
+    [actions, config.steps.PARTNER_B],
+  );
+
+  const handlePartnerABack = useCallback(() => {
+    const targetStep =
+      state.selectedScenarioId === config.customScenarioId
+        ? config.steps.TEXT_INPUT
+        : config.steps.SCENARIO_PREVIEW;
+    actions.setStep(targetStep);
+  }, [actions, config, state.selectedScenarioId]);
+
+  const handlePartnerBContinue = useCallback(
+    (image: UploadedImage, name: string) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CoupleFutureHandlers] 🎬 handlePartnerBContinue called");
+      }
+      actions.requireFeature(() => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[CoupleFutureHandlers] 🚀 Executing: setPartnerB, setPartnerBName, startGeneration");
+        }
+        actions.setPartnerB(image);
+        actions.setPartnerBName(name);
+        actions.startGeneration();
+      });
+    },
+    [actions],
+  );
+
+  const handlePartnerBBack = useCallback(
+    () => actions.setStep(config.steps.PARTNER_A),
+    [actions, config.steps.PARTNER_A],
+  );
+
+  const handleMagicPromptContinue = useCallback(
+    (prompt: string, style: string) => {
+      actions.setCustomPrompt(prompt);
+      actions.setVisualStyle(style);
+      if (state.selectedScenarioId === config.customScenarioId) {
+        actions.setStep(config.steps.PARTNER_A);
+      } else {
+        actions.startGeneration();
+      }
+    },
+    [actions, config, state.selectedScenarioId],
+  );
+
+  const handleMagicPromptBack = useCallback(
+    () => actions.setStep(config.steps.SCENARIO_PREVIEW),
+    [actions, config.steps.SCENARIO_PREVIEW],
+  );
+
+  return {
+    handleScenarioSelect,
+    handleScenarioPreviewBack,
+    handleScenarioPreviewContinue,
+    handlePartnerAContinue,
+    handlePartnerABack,
+    handlePartnerBContinue,
+    handlePartnerBBack,
+    handleMagicPromptContinue,
+    handleMagicPromptBack,
+  };
+}

package/src/features/hd-touch-up/presentation/hooks/useHDTouchUpFeature.ts

@@ -16,7 +16,7 @@ export interface UseHDTouchUpFeatureProps {
 export function useHDTouchUpFeature(props: UseHDTouchUpFeatureProps): BaseSingleImageHookReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
 
-  return useSingleImageFeature<HDTouchUpFeatureConfig, HDTouchUpResult>(
+  return useSingleImageFeature<HDTouchUpFeatureConfig>(
     { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
     { buildInput: (imageBase64) => ({ imageBase64 }) },
   );

package/src/features/photo-restoration/presentation/hooks/usePhotoRestoreFeature.ts

@@ -16,7 +16,7 @@ export interface UsePhotoRestoreFeatureProps {
 export function usePhotoRestoreFeature(props: UsePhotoRestoreFeatureProps): BaseSingleImageHookReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
 
-  return useSingleImageFeature<PhotoRestoreFeatureConfig, PhotoRestoreResult>(
+  return useSingleImageFeature<PhotoRestoreFeatureConfig>(
     { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
     { buildInput: (imageBase64) => ({ imageBase64 }) },
   );

package/src/features/remove-background/presentation/hooks/useRemoveBackgroundFeature.ts

@@ -16,7 +16,7 @@ export interface UseRemoveBackgroundFeatureProps {
 export function useRemoveBackgroundFeature(props: UseRemoveBackgroundFeatureProps): BaseSingleImageHookReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
 
-  return useSingleImageFeature<RemoveBackgroundFeatureConfig, RemoveBackgroundResult>(
+  return useSingleImageFeature<RemoveBackgroundFeatureConfig>(
     { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
     {
       buildInput: (imageBase64, cfg) => ({

package/src/features/upscaling/presentation/hooks/useUpscaleFeature.ts

@@ -16,7 +16,7 @@ export interface UseUpscaleFeatureProps {
 export function useUpscaleFeature(props: UseUpscaleFeatureProps): BaseSingleImageHookReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
 
-  return useSingleImageFeature<UpscaleFeatureConfig, UpscaleResult>(
+  return useSingleImageFeature<UpscaleFeatureConfig>(
     { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
     {
       buildInput: (imageBase64, cfg) => ({

package/src/presentation/hooks/generation/index.ts

@@ -24,6 +24,7 @@ export type {
   ModerationCallbacks,
   ModerationResult,
   CreditCallbacks,
+  LifecycleConfig,
 } from "./types";
 
 export type {

package/src/presentation/hooks/generation/orchestrator.ts

@@ -7,9 +7,10 @@
  * - Error handling
  * - Alert display
  * - Progress tracking
+ * - Lifecycle management (navigation, cleanup)
  */
 
-import { useState, useCallback, useRef } from "react";
+import { useState, useCallback, useRef, useEffect } from "react";
 import { useOfflineStore, useAlert } from "@umituz/react-native-design-system";
 import { useDeductCredit } from "@umituz/react-native-subscription";
 import { createGenerationError, getAlertMessage, parseError } from "./errors";
@@ -17,6 +18,7 @@ import type {
   GenerationStrategy,
   GenerationConfig,
   GenerationState,
+  GenerationError,
   UseGenerationOrchestratorReturn,
 } from "./types";
 
@@ -30,24 +32,42 @@ const INITIAL_STATE = {
   error: null,
 };
 
+const DEFAULT_COMPLETE_DELAY = 500;
+const DEFAULT_RESET_DELAY = 1000;
+
 export const useGenerationOrchestrator = <TInput, TResult>(
   strategy: GenerationStrategy<TInput, TResult>,
   config: GenerationConfig,
 ): UseGenerationOrchestratorReturn<TInput, TResult> => {
-  const { userId, alertMessages, onCreditsExhausted, onSuccess, onError, auth, moderation, credits } = config;
+  const {
+    userId,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess,
+    onError,
+    auth,
+    moderation,
+    credits,
+    lifecycle,
+  } = config;
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[Orchestrator] Hook initialized:", {
+    console.log("[Orchestrator] 🎬 Hook initialized:", {
       userId,
       hasAuth: !!auth,
       hasModeration: !!moderation,
       hasCreditsCallbacks: !!credits,
+      hasLifecycle: !!lifecycle,
     });
   }
 
   const [state, setState] = useState<GenerationState<TResult>>(INITIAL_STATE);
   const isGeneratingRef = useRef(false);
   const pendingInputRef = useRef<TInput | null>(null);
+  const completeTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const resetTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const isMountedRef = useRef(true);
+
   const offlineStore = useOfflineStore();
   const { showError, showSuccess } = useAlert();
   const defaultCredits = useDeductCredit({ userId, onCreditsExhausted });
@@ -57,6 +77,81 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   const deductCredit = credits?.deductCredits ?? defaultCredits.deductCredit;
   const handleCreditsExhausted = credits?.onCreditsExhausted ?? onCreditsExhausted;
 
+  // Cleanup on unmount
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (completeTimeoutRef.current) {
+        clearTimeout(completeTimeoutRef.current);
+        completeTimeoutRef.current = null;
+      }
+      if (resetTimeoutRef.current) {
+        clearTimeout(resetTimeoutRef.current);
+        resetTimeoutRef.current = null;
+      }
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] 🧹 Cleanup: cleared all timeouts");
+      }
+    };
+  }, []);
+
+  // Handle lifecycle completion
+  const handleLifecycleComplete = useCallback(
+    (status: "success" | "error", result?: TResult, error?: GenerationError) => {
+      if (!lifecycle?.onComplete) return;
+
+      const delay = lifecycle.completeDelay ?? DEFAULT_COMPLETE_DELAY;
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] ⏱️ Scheduling lifecycle.onComplete:", { status, delay });
+      }
+
+      // Clear any existing timeout
+      if (completeTimeoutRef.current) {
+        clearTimeout(completeTimeoutRef.current);
+      }
+
+      completeTimeoutRef.current = setTimeout(() => {
+        if (!isMountedRef.current) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ⚠️ Component unmounted, skipping onComplete");
+          }
+          return;
+        }
+
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] 📍 Calling lifecycle.onComplete:", status);
+        }
+
+        lifecycle.onComplete?.(status, result, error);
+
+        // Auto-reset if configured
+        if (lifecycle.autoReset) {
+          const resetDelay = lifecycle.resetDelay ?? DEFAULT_RESET_DELAY;
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] 🔄 Scheduling auto-reset in:", resetDelay);
+          }
+
+          if (resetTimeoutRef.current) {
+            clearTimeout(resetTimeoutRef.current);
+          }
+
+          resetTimeoutRef.current = setTimeout(() => {
+            if (isMountedRef.current) {
+              if (typeof __DEV__ !== "undefined" && __DEV__) {
+                console.log("[Orchestrator] 🔄 Auto-reset triggered");
+              }
+              setState(INITIAL_STATE);
+              isGeneratingRef.current = false;
+            }
+          }, resetDelay);
+        }
+      }, delay);
+    },
+    [lifecycle],
+  );
+
   // Core execution logic (after all checks pass)
   const executeGeneration = useCallback(
     async (input: TInput) => {
@@ -71,18 +166,24 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[Orchestrator] 📊 Progress update:", progress);
         }
-        setState((prev) => ({ ...prev, progress }));
+        if (isMountedRef.current) {
+          setState((prev) => ({ ...prev, progress }));
+        }
       });
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] ✅ strategy.execute() completed");
       }
 
-      setState((prev) => ({ ...prev, progress: 70 }));
+      if (isMountedRef.current) {
+        setState((prev) => ({ ...prev, progress: 70 }));
+      }
 
       // Save result
       if (strategy.save && userId) {
-        setState((prev) => ({ ...prev, status: "saving" }));
+        if (isMountedRef.current) {
+          setState((prev) => ({ ...prev, status: "saving" }));
+        }
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[Orchestrator] 💾 Saving result...");
         }
@@ -99,7 +200,9 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         }
       }
 
-      setState((prev) => ({ ...prev, progress: 90 }));
+      if (isMountedRef.current) {
+        setState((prev) => ({ ...prev, progress: 90 }));
+      }
 
       // Deduct credit
       if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -108,7 +211,9 @@ export const useGenerationOrchestrator = <TInput, TResult>(
       await deductCredit(creditCost);
 
       // Success
-      setState({ status: "success", isGenerating: false, progress: 100, result, error: null });
+      if (isMountedRef.current) {
+        setState({ status: "success", isGenerating: false, progress: 100, result, error: null });
+      }
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] 🎉 Generation SUCCESS");
@@ -118,9 +223,13 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         void showSuccess("Success", alertMessages.success);
       }
 
+      // Call onSuccess callback
       onSuccess?.(result);
+
+      // Handle lifecycle completion
+      handleLifecycleComplete("success", result);
     },
-    [strategy, userId, alertMessages, deductCredit, showSuccess, onSuccess],
+    [strategy, userId, alertMessages, deductCredit, showSuccess, onSuccess, handleLifecycleComplete],
   );
 
   const generate = useCallback(
@@ -217,7 +326,9 @@ export const useGenerationOrchestrator = <TInput, TResult>(
                     console.log("[Orchestrator] User cancelled after moderation warning");
                   }
                   isGeneratingRef.current = false;
-                  setState(INITIAL_STATE);
+                  if (isMountedRef.current) {
+                    setState(INITIAL_STATE);
+                  }
                 },
                 async () => {
                   // User continued - execute generation
@@ -228,9 +339,12 @@ export const useGenerationOrchestrator = <TInput, TResult>(
                     await executeGeneration(input);
                   } catch (err) {
                     const error = parseError(err);
-                    setState({ status: "error", isGenerating: false, progress: 0, result: null, error });
+                    if (isMountedRef.current) {
+                      setState({ status: "error", isGenerating: false, progress: 0, result: null, error });
+                    }
                     void showError("Error", getAlertMessage(error, alertMessages));
                     onError?.(error);
+                    handleLifecycleComplete("error", undefined, error);
                   } finally {
                     isGeneratingRef.current = false;
                   }
@@ -253,9 +367,14 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[Orchestrator] ❌ Generation ERROR:", error);
         }
-        setState({ status: "error", isGenerating: false, progress: 0, result: null, error });
+        if (isMountedRef.current) {
+          setState({ status: "error", isGenerating: false, progress: 0, result: null, error });
+        }
         void showError("Error", getAlertMessage(error, alertMessages));
         onError?.(error);
+
+        // Handle lifecycle completion for errors
+        handleLifecycleComplete("error", undefined, error);
       } finally {
         isGeneratingRef.current = false;
         if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -274,6 +393,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
       executeGeneration,
       showError,
       onError,
+      handleLifecycleComplete,
     ],
   );
 

package/src/presentation/hooks/generation/types.ts

@@ -71,6 +71,25 @@ export interface CreditCallbacks {
   onCreditsExhausted?: () => void;
 }
 
+/**
+ * Lifecycle configuration for generation flow
+ * Centralizes post-generation behavior (navigation, cleanup, etc.)
+ */
+export interface LifecycleConfig {
+  /** Callback after generation completes (success or error) - for navigation, state updates */
+  onComplete?: (
+    status: "success" | "error",
+    result?: unknown,
+    error?: GenerationError,
+  ) => void;
+  /** Delay before calling onComplete (ms) - allows UI to show success state */
+  completeDelay?: number;
+  /** Auto-reset state after completion */
+  autoReset?: boolean;
+  /** Delay before auto-reset (ms) */
+  resetDelay?: number;
+}
+
 export interface GenerationConfig {
   userId: string | undefined;
   alertMessages: AlertMessages;
@@ -83,6 +102,8 @@ export interface GenerationConfig {
   moderation?: ModerationCallbacks;
   /** Optional credit callbacks - if provided, overrides default useDeductCredit */
   credits?: CreditCallbacks;
+  /** Lifecycle configuration for post-generation behavior */
+  lifecycle?: LifecycleConfig;
 }
 
 export interface GenerationState<TResult> {