@umituz/react-native-ai-generation-content 1.72.4 → 1.72.6

package/package.json

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

package/src/domains/access-control/hooks/useAIFeatureGate.ts

@@ -17,16 +17,34 @@ import type {
   AIFeatureGateReturn,
 } from "../types/access-control.types";
 
+declare const __DEV__: boolean;
+
 const handlePromiseResult = (
   result: void | Promise<void>,
   onSuccess?: () => void,
   onError?: (error: Error) => void,
 ): void => {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[AIFeatureGate] handlePromiseResult - isPromise:", result instanceof Promise);
+  }
   if (result instanceof Promise) {
     result
-      .then(() => onSuccess?.())
-      .catch((err) => onError?.(err instanceof Error ? err : new Error(String(err))));
+      .then(() => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] Promise resolved, calling onSuccess");
+        }
+        onSuccess?.();
+      })
+      .catch((err) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] Promise rejected:", err);
+        }
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+      });
   } else {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[AIFeatureGate] Sync result, calling onSuccess");
+    }
     onSuccess?.();
   }
 };
@@ -62,18 +80,45 @@ export function useAIFeatureGate(options: AIFeatureGateOptions): AIFeatureGateRe
 
   const requireFeature = useCallback(
     (action: () => void | Promise<void>): void => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[AIFeatureGate] requireFeature called:", {
+          isOffline,
+          isAuthenticated,
+          isCreditsLoaded,
+          isPremium,
+          creditBalance,
+          creditCost,
+          hasCredits,
+        });
+      }
+
       if (isOffline) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] BLOCKED: User is offline");
+        }
         onNetworkError?.();
         return;
       }
 
-      if (isAuthenticated && !isCreditsLoaded) return;
+      if (isAuthenticated && !isCreditsLoaded) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] BLOCKED: User authenticated but credits not loaded yet");
+        }
+        return;
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[AIFeatureGate] Calling requireFeatureFromPackage");
+      }
 
       requireFeatureFromPackage(() => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[AIFeatureGate] Inside requireFeatureFromPackage callback - executing action");
+        }
         handlePromiseResult(action(), onSuccess, onError);
       });
     },
-    [isOffline, isAuthenticated, isCreditsLoaded, onNetworkError, requireFeatureFromPackage, onSuccess, onError],
+    [isOffline, isAuthenticated, isCreditsLoaded, isPremium, creditBalance, creditCost, hasCredits, onNetworkError, requireFeatureFromPackage, onSuccess, onError],
   );
 
   return {

package/src/domains/background/infrastructure/services/job-poller.service.ts

@@ -77,6 +77,26 @@ export async function pollJob<T = unknown>(
     signal,
   } = options;
 
+  // Validate requestId early
+  if (!requestId || typeof requestId !== "string" || requestId.trim() === "") {
+    return {
+      success: false,
+      error: new Error("Invalid requestId provided"),
+      attempts: 0,
+      elapsedMs: 0,
+    };
+  }
+
+  // Validate model early
+  if (!model || typeof model !== "string" || model.trim() === "") {
+    return {
+      success: false,
+      error: new Error("Invalid model provided"),
+      attempts: 0,
+      elapsedMs: 0,
+    };
+  }
+
   const pollingConfig = { ...DEFAULT_POLLING_CONFIG, ...config };
   const { maxAttempts, maxTotalTimeMs, maxConsecutiveErrors } = pollingConfig;
 

package/src/domains/background/presentation/hooks/use-pending-jobs.ts

@@ -85,7 +85,8 @@ export function usePendingJobs<TInput = unknown, TResult = unknown>(
     onSuccess: (id: string) => {
       queryClient.setQueryData<BackgroundJob<TInput, TResult>[]>(
         queryKey,
-        (old: BackgroundJob<TInput, TResult>[] | undefined) => old?.filter((job: BackgroundJob<TInput, TResult>) => job.id !== id) ?? [],
+        (old: BackgroundJob<TInput, TResult>[] | undefined) =>
+          old?.filter((job: BackgroundJob<TInput, TResult>) => job && job.id !== id) ?? [],
       );
     },
   });
@@ -95,7 +96,8 @@ export function usePendingJobs<TInput = unknown, TResult = unknown>(
     onSuccess: () => {
       queryClient.setQueryData<BackgroundJob<TInput, TResult>[]>(
         queryKey,
-        (old: BackgroundJob<TInput, TResult>[] | undefined) => old?.filter((job: BackgroundJob<TInput, TResult>) => job.status !== "completed") ?? [],
+        (old: BackgroundJob<TInput, TResult>[] | undefined) =>
+          old?.filter((job: BackgroundJob<TInput, TResult>) => job && job.status !== "completed") ?? [],
       );
     },
   });
@@ -105,7 +107,8 @@ export function usePendingJobs<TInput = unknown, TResult = unknown>(
     onSuccess: () => {
       queryClient.setQueryData<BackgroundJob<TInput, TResult>[]>(
         queryKey,
-        (old: BackgroundJob<TInput, TResult>[] | undefined) => old?.filter((job: BackgroundJob<TInput, TResult>) => job.status !== "failed") ?? [],
+        (old: BackgroundJob<TInput, TResult>[] | undefined) =>
+          old?.filter((job: BackgroundJob<TInput, TResult>) => job && job.status !== "failed") ?? [],
       );
     },
   });

package/src/domains/creations/presentation/hooks/useCreationPersistence.ts

@@ -3,6 +3,8 @@
  */
 
 import { useCallback, useMemo } from "react";
+
+declare const __DEV__: boolean;
 import { useAuth } from "@umituz/react-native-auth";
 import { createCreationsRepository } from "../../infrastructure/adapters";
 import type { Creation } from "../../domain/entities/Creation";
@@ -68,7 +70,14 @@ export function useCreationPersistence(
       });
 
       if (creditCost && onCreditDeduct) {
-        onCreditDeduct(creditCost).catch(() => {});
+        onCreditDeduct(creditCost).catch((error) => {
+          // Log credit deduction errors for debugging
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[CreationPersistence] Credit deduction failed:", error);
+          }
+          // Don't throw - credit deduction failure shouldn't block completion
+          // But we should notify user or retry in production
+        });
       }
     },
     [userId, repository, creditCost, onCreditDeduct]

package/src/domains/creations/presentation/hooks/useProcessingJobsPoller.ts

@@ -42,6 +42,14 @@ export function useProcessingJobsPoller(
   const pollingRef = useRef<Set<string>>(new Set());
   const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
 
+  // Convert to IDs to prevent re-creating array on every render
+  const processingJobIds = useMemo(
+    () => creations
+      .filter((c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model)
+      .map((c) => c.id),
+    [creations],
+  );
+
   const processingJobs = useMemo(
     () => creations.filter(
       (c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model,
@@ -104,7 +112,7 @@ export function useProcessingJobsPoller(
   };
 
   useEffect(() => {
-    if (!enabled || !userId || processingJobs.length === 0) {
+    if (!enabled || !userId || processingJobIds.length === 0) {
       if (intervalRef.current) {
         clearInterval(intervalRef.current);
         intervalRef.current = null;
@@ -112,13 +120,19 @@ export function useProcessingJobsPoller(
       return;
     }
 
+    // Get current jobs at poll time to avoid stale closures
+    const pollCurrentJobs = () => {
+      const currentJobs = creations.filter(
+        (c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model,
+      );
+      currentJobs.forEach((job) => pollJobRef.current?.(job));
+    };
+
     // Initial poll
-    processingJobs.forEach((job) => pollJobRef.current?.(job));
+    pollCurrentJobs();
 
     // Set up interval polling
-    intervalRef.current = setInterval(() => {
-      processingJobs.forEach((job) => pollJobRef.current?.(job));
-    }, DEFAULT_POLL_INTERVAL_MS);
+    intervalRef.current = setInterval(pollCurrentJobs, DEFAULT_POLL_INTERVAL_MS);
 
     return () => {
       // Clear polling set first to prevent new operations
@@ -130,7 +144,7 @@ export function useProcessingJobsPoller(
         intervalRef.current = null;
       }
     };
-  }, [enabled, userId, processingJobs]);
+  }, [enabled, userId, processingJobIds, creations]);
 
   return {
     processingCount: processingJobs.length,

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

@@ -83,14 +83,17 @@ function applyStyleEnhancements(prompt: string, wizardData: Record<string, unkno
 export function createImageStrategy(options: CreateImageStrategyOptions): WizardStrategy {
   const { scenario, creditCost } = options;
 
+  // Validate model early - fail fast
+  if (!scenario.model) {
+    throw new Error("Model is required for image generation");
+  }
+
+  const model = scenario.model;
+
   return {
     execute: async (input: unknown) => {
       const imageInput = input as WizardImageInput;
-      if (!scenario.model) {
-        throw new Error("Model is required for image generation");
-      }
-
-      const result = await executeImageGeneration(imageInput, scenario.model);
+      const result = await executeImageGeneration(imageInput, model);
 
       if (!result.success || !result.imageUrl) {
         throw new Error(result.error || "Image generation failed");

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

@@ -55,13 +55,31 @@ export async function extractPhotosAsBase64(
     return [];
   }
 
-  const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
-  const validPhotos = photosBase64.filter(Boolean) as string[];
+  // Use Promise.allSettled to handle individual failures gracefully
+  const results = await Promise.allSettled(
+    photoUris.map(async (uri, index) => {
+      try {
+        return await readFileAsBase64(uri);
+      } catch (error) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error(`[PhotoExtraction] Failed to read photo ${index}:`, error);
+        }
+        return null;
+      }
+    })
+  );
+
+  // Extract successful results only
+  const validPhotos = results
+    .map((result) => (result.status === "fulfilled" ? result.value : null))
+    .filter((photo): photo is string => typeof photo === "string" && photo.length > 0);
 
   if (enableDebugLogs && typeof __DEV__ !== "undefined" && __DEV__) {
+    const failedCount = results.filter((r) => r.status === "rejected").length;
     console.log("[PhotoExtraction] Converted photos", {
       total: photoUris.length,
       valid: validPhotos.length,
+      failed: failedCount,
       sizes: validPhotos.map((p) => `${(p.length / 1024).toFixed(1)}KB`),
     });
   }

package/src/domains/generation/wizard/presentation/hooks/generationExecutor.ts

@@ -44,9 +44,13 @@ export const executeWizardGeneration = async (params: ExecuteGenerationParams):
       console.log("[WizardGeneration] GENERATING -", isVideoMode ? "VIDEO" : "PHOTO");
     }
 
-    const typedInput = input as { prompt?: string };
+    // Safely extract prompt with type guard
+    const prompt = typeof input === "object" && input !== null && "prompt" in input && typeof input.prompt === "string"
+      ? input.prompt
+      : "";
+
     const generationFn = isVideoMode ? videoGenerationFn : photoGenerationFn;
-    await generationFn(input, typedInput.prompt || "");
+    await generationFn(input, prompt);
 
     if (isMountedRef.current) {
       dispatch({ type: "COMPLETE" });

package/src/domains/generation/wizard/presentation/hooks/usePhotoUploadState.ts

@@ -5,6 +5,8 @@
  */
 
 import { useState, useCallback, useEffect, useRef } from "react";
+
+declare const __DEV__: boolean;
 import { useMedia, MediaQuality, MediaValidationError, MEDIA_CONSTANTS } from "@umituz/react-native-design-system";
 import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
 
@@ -51,6 +53,15 @@ export const usePhotoUploadState = ({
   const { pickImage, isLoading } = useMedia();
   const timeoutRef = useRef<NodeJS.Timeout | undefined>(undefined);
 
+  // Use refs to avoid effect re-runs on callback changes
+  const onErrorRef = useRef(onError);
+  const translationsRef = useRef(translations);
+
+  useEffect(() => {
+    onErrorRef.current = onError;
+    translationsRef.current = translations;
+  }, [onError, translations]);
+
   const maxFileSizeMB = config?.maxFileSizeMB ?? MEDIA_CONSTANTS.MAX_IMAGE_SIZE_MB;
 
   useEffect(() => {
@@ -61,28 +72,31 @@ export const usePhotoUploadState = ({
   }, [stepId, initialImage]);
 
   useEffect(() => {
+    // Clear any existing timeout first
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = undefined;
+    }
+
     if (isLoading) {
       timeoutRef.current = setTimeout(() => {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.warn("[usePhotoUploadState] Image picker timeout - possible stuck state");
         }
-        onError?.({
-          title: translations.error,
+        onErrorRef.current?.({
+          title: translationsRef.current.error,
           message: "Image selection is taking too long. Please try again.",
         });
       }, 30000);
-    } else {
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current);
-      }
     }
 
     return () => {
       if (timeoutRef.current) {
         clearTimeout(timeoutRef.current);
+        timeoutRef.current = undefined;
       }
     };
-  }, [isLoading, onError, translations]);
+  }, [isLoading]);
 
   const clearImage = useCallback(() => {
     setImage(null);

package/src/domains/generation/wizard/presentation/hooks/useVideoQueueGeneration.ts

@@ -3,6 +3,8 @@
  */
 
 import { useEffect, useRef, useCallback, useState } from "react";
+
+declare const __DEV__: boolean;
 import { pollQueueStatus } from "./videoQueuePoller";
 import { DEFAULT_POLL_INTERVAL_MS } from "../../../../../infrastructure/constants/polling.constants";
 import type { GenerationUrls } from "./generation-result.utils";
@@ -50,7 +52,11 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
             imageUrl: urls.imageUrl,
             videoUrl: urls.videoUrl,
           });
-        } catch {}
+        } catch (error) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[VideoQueue] Failed to update completion status:", error);
+          }
+        }
       }
       resetRefs();
       onSuccess?.(urls);
@@ -64,7 +70,11 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       if (creationId && userId) {
         try {
           await persistence.updateToFailed(userId, creationId, errorMsg);
-        } catch {}
+        } catch (error) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[VideoQueue] Failed to update error status:", error);
+          }
+        }
       }
       resetRefs();
       onError?.(errorMsg);
@@ -107,7 +117,11 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
             prompt,
           });
           creationIdRef.current = creationId;
-        } catch {}
+        } catch (error) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[VideoQueue] Failed to save processing creation:", error);
+          }
+        }
       }
 
       const queueResult = await strategy.submitToQueue(input);
@@ -126,7 +140,11 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       if (creationId && userId && queueResult.requestId && queueResult.model) {
         try {
           await persistence.updateRequestId(userId, creationId, queueResult.requestId, queueResult.model);
-        } catch {}
+        } catch (error) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[VideoQueue] Failed to update request ID:", error);
+          }
+        }
       }
 
       pollingRef.current = setInterval(() => void pollStatus(), DEFAULT_POLL_INTERVAL_MS);

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

@@ -72,7 +72,8 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
     if (isGeneratingStep && state.status === "IDLE" && !isAlreadyGenerating) {
       dispatch({ type: "START_PREPARATION" });
 
-      executeWizardGeneration({
+      // Execute generation and handle errors properly
+      void executeWizardGeneration({
         wizardData,
         scenario,
         isVideoMode,
@@ -81,6 +82,13 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
         onError,
         videoGenerationFn: videoGeneration.startGeneration,
         photoGenerationFn: photoGeneration.startGeneration,
+      }).catch((error) => {
+        // Catch any unhandled errors from executeWizardGeneration
+        if (isMountedRef.current) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          dispatch({ type: "ERROR", error: errorMsg });
+          onError?.(errorMsg);
+        }
       });
     }
 

package/src/domains/generation/wizard/presentation/hooks/videoQueuePoller.ts

@@ -16,12 +16,15 @@ interface PollParams {
 export const pollQueueStatus = async (params: PollParams): Promise<void> => {
   const { requestId, model, isPollingRef, pollingRef, onComplete, onError } = params;
 
+  // Atomic check-and-set to prevent race condition
   if (isPollingRef.current) return;
+  isPollingRef.current = true;
 
   const provider = providerRegistry.getActiveProvider();
-  if (!provider) return;
-
-  isPollingRef.current = true;
+  if (!provider) {
+    isPollingRef.current = false;
+    return;
+  }
   try {
     const status = await provider.getJobStatus(model, requestId);
     if (__DEV__) console.log("[VideoQueueGeneration] Poll:", status.status);

package/src/domains/image-to-video/presentation/hooks/imageToVideoStrategy.ts

@@ -1,4 +1,6 @@
 import { executeImageToVideo } from "../../infrastructure/services";
+
+declare const __DEV__: boolean;
 import type { GenerationStrategy } from "../../../../presentation/hooks/generation";
 import type {
   ImageToVideoFeatureConfig,
@@ -41,7 +43,11 @@ export const createImageToVideoStrategy = (
         type: "image-to-video",
         imageUri: input.imageUrl,
         metadata: input.options as Record<string, unknown> | undefined,
-      }).catch(() => {});
+      }).catch((error) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[ImageToVideo] onGenerationStart callback failed:", error);
+        }
+      });
 
       const result = await executeImageToVideo(
         { imageUri: input.imageUrl, userId, motionPrompt: input.prompt, options: input.options },

package/src/domains/result-preview/presentation/hooks/useResultActions.ts

@@ -4,6 +4,8 @@
  */
 
 import { useState, useCallback } from "react";
+
+declare const __DEV__: boolean;
 import * as MediaLibrary from "expo-media-library";
 import * as Sharing from "expo-sharing";
 import {
@@ -88,7 +90,10 @@ export const useResultActions = (options: UseResultActionsOptions = {}): UseResu
         onShareEnd?.(true);
       }
     } catch (error: unknown) {
-      if (__DEV__) console.log("Share cancelled or failed:", error);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.log("[ResultActions] Share cancelled or failed:", errorMsg);
+      }
       onShareEnd?.(true);
     } finally {
       setIsSharing(false);

package/src/domains/scenarios/presentation/screens/HierarchicalScenarioListScreen.tsx

@@ -39,7 +39,7 @@ export const HierarchicalScenarioListScreen: React.FC<HierarchicalScenarioListSc
   onSelectScenario,
   onBack,
   t,
-  numColumns = 1,
+  numColumns = 2,
   isLoading = false,
 }) => {
   const tokens = useAppDesignTokens();
@@ -133,7 +133,7 @@ export const HierarchicalScenarioListScreen: React.FC<HierarchicalScenarioListSc
           data={filteredScenarios}
           numColumns={numColumns}
           showsVerticalScrollIndicator={false}
-          columnWrapperStyle={numColumns > 1 ? styles.row : undefined}
+          columnWrapperStyle={styles.row}
           renderItem={renderItem}
           keyExtractor={(item) => item.id}
           ListEmptyComponent={isLoading ? LoadingComponent : (filteredScenarios.length === 0 ? ListEmptyComponent : null)}

package/src/domains/text-to-video/presentation/hooks/textToVideoStrategy.ts

@@ -1,4 +1,6 @@
 import { executeTextToVideo } from "../../infrastructure/services";
+
+declare const __DEV__: boolean;
 import type { GenerationStrategy } from "../../../../presentation/hooks/generation";
 import type {
   TextToVideoConfig,
@@ -40,7 +42,11 @@ export const createTextToVideoStrategy = (
         type: "text-to-video",
         prompt: input.prompt,
         metadata: input.options as Record<string, unknown> | undefined,
-      }).catch(() => {});
+      }).catch((error) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[TextToVideo] onGenerationStart callback failed:", error);
+        }
+      });
 
       const result = await executeTextToVideo(
         { prompt: input.prompt, userId, options: input.options },

package/src/infrastructure/services/generation-orchestrator.service.ts

@@ -86,6 +86,11 @@ class GenerationOrchestratorService {
         throw pollResult.error ?? new Error("Polling failed");
       }
 
+      // Validate result exists before type assertion
+      if (!pollResult.data) {
+        throw new Error("Polling succeeded but no data returned");
+      }
+
       const result = pollResult.data as T;
       const duration = Date.now() - startTime;
 

package/src/infrastructure/services/image-feature-executor.service.ts

@@ -72,10 +72,15 @@ export async function executeImageFeature(
       };
     }
 
+    // Safely extract requestId with type guard
+    const requestId = typeof result === "object" && result !== null && "requestId" in result && typeof result.requestId === "string"
+      ? result.requestId
+      : undefined;
+
     return {
       success: true,
       imageUrl,
-      requestId: (result as { requestId?: string })?.requestId,
+      requestId,
     };
   } catch (error) {
     const message = extractErrorMessage(error, "Processing failed", `Image:${featureType}`);

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

@@ -34,6 +34,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   const isGeneratingRef = useRef(false);
   const isMountedRef = useRef(true);
   const abortControllerRef = useRef<AbortController | null>(null);
+  const cleanupTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
   const offlineStore = useOfflineStore();
   const { showError, showSuccess } = useAlert();
@@ -44,43 +45,92 @@ export const useGenerationOrchestrator = <TInput, TResult>(
     return () => {
       isMountedRef.current = false;
       abortControllerRef.current?.abort();
+      // Clear any pending lifecycle complete timeout
+      if (cleanupTimeoutRef.current) {
+        clearTimeout(cleanupTimeoutRef.current);
+        cleanupTimeoutRef.current = null;
+      }
     };
   }, []);
 
   const handleLifecycleComplete = useCallback(
     (status: "success" | "error", result?: TResult, error?: GenerationError) => {
       if (!lifecycle?.onComplete) return;
+
+      // Clear any existing timeout first
+      if (cleanupTimeoutRef.current) {
+        clearTimeout(cleanupTimeoutRef.current);
+        cleanupTimeoutRef.current = null;
+      }
+
       const delay = lifecycle.completeDelay ?? 500;
-      const timeoutId = setTimeout(() => {
-        if (isMountedRef.current) lifecycle.onComplete?.(status, result, error);
+      cleanupTimeoutRef.current = setTimeout(() => {
+        if (isMountedRef.current) {
+          lifecycle.onComplete?.(status, result, error);
+        }
+        cleanupTimeoutRef.current = null;
       }, delay);
-      // Store timeout ID for cleanup (if component unmounts during delay)
-      return () => clearTimeout(timeoutId);
     },
     [lifecycle],
   );
 
   const executeGeneration = useCallback(
     async (input: TInput) => {
-      const creditDeducted = await deductCredit(strategy.getCreditCost());
-      if (!creditDeducted) throw createGenerationError("credits", alertMessages.creditFailed);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] ----------------------------------------");
+        console.log("[Orchestrator] executeGeneration() called");
+      }
+
+      const creditCost = strategy.getCreditCost();
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] Deducting credits:", creditCost);
+      }
+
+      const creditDeducted = await deductCredit(creditCost);
+      if (!creditDeducted) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] ERROR: Credit deduction failed");
+        }
+        throw createGenerationError("credits", alertMessages.creditFailed);
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] Credits deducted successfully");
+      }
 
       setState((prev) => ({ ...prev, status: "generating" }));
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Starting generation");
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] State: generating - calling strategy.execute()");
+      }
 
       const result = await strategy.execute(input);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] strategy.execute() completed");
+      }
 
       if (strategy.save && userId) {
         if (isMountedRef.current) setState((prev) => ({ ...prev, status: "saving" }));
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Saving result to Firestore");
+        }
         try {
           await strategy.save(result, userId);
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] Result saved successfully");
+          }
         } catch (saveErr) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ERROR: Save failed:", saveErr);
+          }
           throw createGenerationError("save", alertMessages.saveFailed, saveErr instanceof Error ? saveErr : undefined);
         }
       }
 
       if (isMountedRef.current) setState({ status: "success", isGenerating: false, result, error: null });
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Generation SUCCESS");
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] ✅ Generation SUCCESS");
+        console.log("[Orchestrator] ========================================");
+      }
 
       if (alertMessages.success) showSuccess("Success", alertMessages.success);
       onSuccess?.(result);
@@ -92,41 +142,81 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 
   const generate = useCallback(
     async (input: TInput) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] generate() called");
-      if (isGeneratingRef.current) return;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] ========================================");
+        console.log("[Orchestrator] generate() called with input:", JSON.stringify(input).substring(0, 200));
+        console.log("[Orchestrator] isGenerating:", isGeneratingRef.current);
+        console.log("[Orchestrator] userId:", userId);
+      }
+
+      if (isGeneratingRef.current) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] BLOCKED: Already generating");
+        }
+        return;
+      }
 
       // Create new AbortController for this generation
       abortControllerRef.current = new AbortController();
       isGeneratingRef.current = true;
       setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
 
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] State set to 'checking', isGenerating: true");
+      }
+
       try {
         // Check online status inside the try block to avoid dependency on offlineStore.isOnline
         if (!offlineStore.isOnline) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ERROR: User is offline");
+          }
           throw createGenerationError("network", alertMessages.networkError);
         }
 
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Online check passed");
+        }
+
         // Check if aborted
         if (abortControllerRef.current.signal.aborted) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ERROR: Generation aborted (1)");
+          }
           throw new Error("Generation aborted");
         }
 
         // Pre-validate credits before generation to catch concurrent consumption
         const creditCost = strategy.getCreditCost();
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Checking credits - cost:", creditCost);
+        }
+
         const hasEnoughCredits = await checkCredits(creditCost);
         if (!hasEnoughCredits) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] Pre-validation: insufficient credits");
+            console.log("[Orchestrator] ERROR: Pre-validation failed - insufficient credits");
           }
           onCreditsExhausted?.();
           throw createGenerationError("credits", alertMessages.creditFailed);
         }
 
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Credit check passed");
+        }
+
         // Check if aborted before moderation
         if (abortControllerRef.current.signal.aborted) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ERROR: Generation aborted (2)");
+          }
           throw new Error("Generation aborted");
         }
 
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Starting moderation check");
+        }
+
         return await handleModeration({
           input,
           moderation,
@@ -161,7 +251,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         abortControllerRef.current = null;
       }
     },
-    [offlineStore.isOnline, moderation, alertMessages, strategy, checkCredits, onCreditsExhausted, executeGeneration, showError, onError, handleLifecycleComplete],
+    [offlineStore, moderation, alertMessages, strategy, checkCredits, onCreditsExhausted, executeGeneration, showError, onError, handleLifecycleComplete],
   );
 
   const reset = useCallback(() => {

package/src/presentation/hooks/generation-flow-navigation.ts

@@ -24,7 +24,11 @@ export function createGoNextHandler(
       onComplete?.(newState);
     } else {
       setState({ ...state, currentStepIndex: nextIndex });
-      onStepChange?.(nextIndex, config.photoSteps[nextIndex]);
+      // Bounds check before accessing array
+      const nextStep = config.photoSteps[nextIndex];
+      if (nextStep) {
+        onStepChange?.(nextIndex, nextStep);
+      }
     }
   };
 }
@@ -40,8 +44,15 @@ export function createGoBackHandler(
     if (!canGoBack) return;
 
     const prevIndex = currentStepIndex - 1;
+    // Validate index is within bounds
+    if (prevIndex < 0) return;
+
     setState((prev) => ({ ...prev, currentStepIndex: prevIndex, isComplete: false }));
-    onStepChange?.(prevIndex, config.photoSteps[prevIndex]);
+    // Bounds check before accessing array
+    const prevStep = config.photoSteps[prevIndex];
+    if (prevStep) {
+      onStepChange?.(prevIndex, prevStep);
+    }
   };
 }
 

package/src/presentation/hooks/use-generation.ts

@@ -88,7 +88,7 @@ export function useGeneration<T = unknown>(
 
         const genResult = await generationOrchestrator.generate<T>(request);
 
-        if (abortRef.current || abortControllerRef.current.signal.aborted) return;
+        if (abortRef.current || abortControllerRef.current?.signal.aborted) return;
 
         setResult(genResult);