@umituz/react-native-ai-generation-content 1.72.5 → 1.72.7

package/package.json

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

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,11 @@ export function useCreationPersistence(
       });
 
       if (creditCost && onCreditDeduct) {
-        onCreditDeduct(creditCost).catch(() => {});
+        onCreditDeduct(creditCost).catch((error) => {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[CreationPersistence] Credit deduction failed:", error);
+          }
+        });
       }
     },
     [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,
@@ -81,6 +89,19 @@ export function useProcessingJobsPoller(
         if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[ProcessingJobsPoller] Completed:", creation.id, urls);
 
         const uri = urls.videoUrl || urls.imageUrl || "";
+
+        // Validate that we have a valid URI before marking as completed
+        if (!uri || uri.trim() === "") {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[ProcessingJobsPoller] No valid URI in result:", creation.id);
+          }
+          await repository.update(userId, creation.id, {
+            status: CREATION_STATUS.FAILED,
+            metadata: { error: "No valid result URL received" },
+          });
+          return;
+        }
+
         await repository.update(userId, creation.id, {
           status: CREATION_STATUS.COMPLETED,
           uri,
@@ -103,8 +124,14 @@ export function useProcessingJobsPoller(
     }
   };
 
+  // Use ref to always get latest creations
+  const creationsRef = useRef(creations);
   useEffect(() => {
-    if (!enabled || !userId || processingJobs.length === 0) {
+    creationsRef.current = creations;
+  }, [creations]);
+
+  useEffect(() => {
+    if (!enabled || !userId || processingJobIds.length === 0) {
       if (intervalRef.current) {
         clearInterval(intervalRef.current);
         intervalRef.current = null;
@@ -112,13 +139,19 @@ export function useProcessingJobsPoller(
       return;
     }
 
+    // Get current jobs at poll time from ref to avoid stale closures
+    const pollCurrentJobs = () => {
+      const currentJobs = creationsRef.current.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 +163,7 @@ export function useProcessingJobsPoller(
         intervalRef.current = null;
       }
     };
-  }, [enabled, userId, processingJobs]);
+  }, [enabled, userId, processingJobIds]);
 
   return {
     processingCount: processingJobs.length,

package/src/domains/generation/infrastructure/flow/useFlowStore.ts

@@ -3,6 +3,8 @@
  */
 
 import { createStore } from "@umituz/react-native-design-system";
+
+declare const __DEV__: boolean;
 import type {
   FlowState,
   FlowActions,
@@ -34,7 +36,13 @@ export const createFlowStore = (config: FlowStoreConfig) => {
   if (config.initialStepIndex !== undefined) {
     initialIndex = Math.max(0, Math.min(config.initialStepIndex, config.steps.length - 1));
   } else if (config.initialStepId) {
-    initialIndex = Math.max(0, config.steps.findIndex((s) => s.id === config.initialStepId));
+    const foundIndex = config.steps.findIndex((s) => s.id === config.initialStepId);
+    if (foundIndex === -1) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn(`[FlowStore] Step "${config.initialStepId}" not found, using first step`);
+      }
+    }
+    initialIndex = Math.max(0, foundIndex);
   }
 
   const initialStepId = config.steps[initialIndex]?.id ?? "";
@@ -86,28 +94,30 @@ export const createFlowStore = (config: FlowStoreConfig) => {
       setScenario: (scenario: unknown) => set({ selectedScenario: scenario }),
 
       setPartnerImage: (partnerId: string, image: FlowUploadedImageData | undefined) =>
-        set({ partners: { ...get().partners, [partnerId]: image } }),
+        set((state) => ({ partners: { ...state.partners, [partnerId]: image } })),
 
       setPartnerName: (partnerId: string, name: string) =>
-        set({ partnerNames: { ...get().partnerNames, [partnerId]: name } }),
+        set((state) => ({ partnerNames: { ...state.partnerNames, [partnerId]: name } })),
 
       setTextInput: (text: string) => set({ textInput: text }),
       setVisualStyle: (styleId: string) => set({ visualStyle: styleId }),
 
       setSelectedFeatures: (featureType: string, ids: readonly string[]) =>
-        set({ selectedFeatures: { ...get().selectedFeatures, [featureType]: ids } }),
+        set((state) => ({ selectedFeatures: { ...state.selectedFeatures, [featureType]: ids } })),
 
       setCustomData: (key: string, value: unknown) =>
-        set({ customData: { ...get().customData, [key]: value } }),
+        set((state) => ({ customData: { ...state.customData, [key]: value } })),
 
       startGeneration: () =>
         set({ generationStatus: "preparing", generationProgress: 0, generationError: undefined }),
 
-      updateProgress: (progress: number) =>
+      updateProgress: (progress: number) => {
+        const validProgress = Math.max(0, Math.min(100, progress));
         set({
-          generationProgress: progress,
-          generationStatus: progress >= 100 ? "completed" : progress > 0 ? "generating" : "preparing",
-        }),
+          generationProgress: validProgress,
+          generationStatus: validProgress >= 100 ? "completed" : validProgress > 0 ? "generating" : "preparing",
+        });
+      },
 
       setResult: (result: unknown) =>
         set({ generationResult: result, generationStatus: "completed", generationProgress: 100 }),

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/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/infrastructure/validation/base-validator.ts

@@ -136,6 +136,10 @@ export function validateBase64(input: unknown): ValidationResult {
     return { isValid: false, errors: ["Input must be a string"] };
   }
 
+  if (input.length === 0) {
+    return { isValid: false, errors: ["Base64 string cannot be empty"] };
+  }
+
   const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
   if (!base64Regex.test(input)) {
     return { isValid: false, errors: ["Invalid base64 format"] };

package/src/presentation/hooks/flow-state.utils.ts

@@ -48,6 +48,12 @@ export function updatePhotoStep(
   stepIndex: number,
   updates: Partial<PhotoStepData>,
 ): GenerationFlowState {
+  // Validate bounds to prevent sparse arrays and undefined access
+  if (stepIndex < 0 || stepIndex >= state.photoSteps.length) {
+    console.warn(`[FlowState] Invalid stepIndex ${stepIndex}, ignoring update`);
+    return state;
+  }
+
   const newPhotoSteps = [...state.photoSteps];
   newPhotoSteps[stepIndex] = {
     ...newPhotoSteps[stepIndex],

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,18 +45,31 @@ 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],
   );
@@ -237,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);
 
@@ -109,6 +109,9 @@ export function useGeneration<T = unknown>(
         if (!abortRef.current && !abortControllerRef.current?.signal.aborted) {
           setIsGenerating(false);
         }
+        if (abortControllerRef.current && !abortControllerRef.current.signal.aborted) {
+          abortControllerRef.current.abort();
+        }
         abortControllerRef.current = null;
       }
     },