@umituz/react-native-ai-generation-content 1.82.8 → 1.83.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.82.8",
+  "version": "1.83.0",
   "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/executors/backgroundJobExecutor.ts

@@ -104,6 +104,13 @@ export const executeQueuedJob = async <TInput, TResult>(
       await executor.onError?.(failedJob, error instanceof Error ? error : new Error(errorMsg));
       onJobError?.(failedJob);
     }
+
+    // Remove failed job from cache to prevent accumulation
+    try {
+      await removeJobAsync(jobId);
+    } catch {
+      // Best effort cleanup
+    }
   } finally {
     // Use atomic Set operation to prevent race conditions
     activeJobsRef.current.delete(jobId);

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

@@ -81,8 +81,13 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
       activeJobsRef.current.delete(id);
       jobInputsRef.current.delete(id);
       removeJob(id);
+
+      // Trigger onAllComplete if no more active jobs after cancel
+      if (activeJobsRef.current.size === 0) {
+        onAllComplete?.();
+      }
     },
-    [removeJob],
+    [removeJob, onAllComplete],
   );
 
   // Calculate active jobs from TanStack Query state (not ref) for reactivity

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

@@ -121,14 +121,14 @@ export const usePhotoUploadState = ({
         }
 
         if (result.error === MediaValidationError.FILE_TOO_LARGE) {
-          onError?.({
-            title: translations.fileTooLarge,
-            message: translations.maxFileSize.replace("{size}", maxFileSizeMB.toString()),
+          onErrorRef.current?.({
+            title: translationsRef.current.fileTooLarge,
+            message: translationsRef.current.maxFileSize.replace("{size}", maxFileSizeMB.toString()),
           });
         } else if (result.error === MediaValidationError.PERMISSION_DENIED) {
-          onError?.({
-            title: translations.error,
-            message: translations.permissionDenied ?? "Permission to access media library is required",
+          onErrorRef.current?.({
+            title: translationsRef.current.error,
+            message: translationsRef.current.permissionDenied ?? "Permission to access media library is required",
           });
         }
         return;
@@ -168,12 +168,12 @@ export const usePhotoUploadState = ({
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.error("[usePhotoUploadState] Error picking image", error);
       }
-      onError?.({
-        title: translations.error,
-        message: translations.uploadFailed,
+      onErrorRef.current?.({
+        title: translationsRef.current.error,
+        message: translationsRef.current.uploadFailed,
       });
     }
-  }, [pickImage, maxFileSizeMB, translations, onError]);
+  }, [pickImage, maxFileSizeMB]);
 
   const canContinue = image !== null && !isLoading;
 

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

@@ -6,7 +6,10 @@ 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 {
+  DEFAULT_POLL_INTERVAL_MS,
+  DEFAULT_MAX_POLL_TIME_MS,
+} from "../../../../../infrastructure/constants/polling.constants";
 import type { GenerationUrls } from "./generation-result.utils";
 import type {
   UseVideoQueueGenerationProps,
@@ -23,6 +26,7 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
   const isGeneratingRef = useRef(false);
   const isPollingRef = useRef(false);
   const consecutiveErrorsRef = useRef(0);
+  const pollStartTimeRef = useRef<number | null>(null);
   const [isGenerating, setIsGenerating] = useState(false);
 
   const clearPolling = useCallback(() => {
@@ -38,6 +42,7 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       isGeneratingRef.current = false;
       isPollingRef.current = false;
       consecutiveErrorsRef.current = 0;
+      pollStartTimeRef.current = null;
       creationIdRef.current = null;
       requestIdRef.current = null;
       modelRef.current = null;
@@ -53,12 +58,12 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
     isGeneratingRef.current = false;
     isPollingRef.current = false;
     consecutiveErrorsRef.current = 0;
+    pollStartTimeRef.current = null;
     setIsGenerating(false);
   }, [clearPolling]);
 
   const handleComplete = useCallback(
     async (urls: GenerationUrls) => {
-      // Stop polling immediately on completion
       clearPolling();
 
       const creationId = creationIdRef.current;
@@ -74,7 +79,6 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
         });
       }
 
-      // Validate non-empty URI
       if (!creationId || !userId || !uri || uri.trim() === "") {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.error("[VideoQueue] ❌ Invalid completion data:", { creationId, userId, uri });
@@ -106,8 +110,6 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
 
       resetRefs();
 
-      // Still call onSuccess even if persistence failed - the generation itself succeeded
-      // The video/image URL is valid, user should still see the result
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[VideoQueue] 🎯 Calling onSuccess callback now...", { persistenceSucceeded });
       }
@@ -139,11 +141,30 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
     [userId, persistence, onError, resetRefs, clearPolling],
   );
 
+  // Use a ref to hold the latest handleComplete/handleError to avoid stale closures
+  // in the setInterval callback
+  const handleCompleteRef = useRef(handleComplete);
+  const handleErrorRef = useRef(handleError);
+  useEffect(() => { handleCompleteRef.current = handleComplete; }, [handleComplete]);
+  useEffect(() => { handleErrorRef.current = handleError; }, [handleError]);
+
   const pollStatus = useCallback(async () => {
     const requestId = requestIdRef.current;
     const model = modelRef.current;
     if (!requestId || !model) return;
 
+    // Check max poll time
+    if (pollStartTimeRef.current !== null) {
+      const elapsed = Date.now() - pollStartTimeRef.current;
+      if (elapsed >= DEFAULT_MAX_POLL_TIME_MS) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn("[VideoQueue] ⏰ Max poll time exceeded, aborting");
+        }
+        await handleErrorRef.current("Generation timed out. Please try again.");
+        return;
+      }
+    }
+
     try {
       await pollQueueStatus({
         requestId,
@@ -151,15 +172,19 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
         isPollingRef,
         pollingRef,
         consecutiveErrorsRef,
-        onComplete: handleComplete,
-        onError: handleError,
+        onComplete: handleCompleteRef.current,
+        onError: handleErrorRef.current,
       });
     } catch (error) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.error("[VideoQueue] Unexpected poll error:", error);
       }
     }
-  }, [handleComplete, handleError]);
+  }, []);
+
+  // Keep a stable ref to pollStatus for the setInterval closure
+  const pollStatusRef = useRef(pollStatus);
+  useEffect(() => { pollStatusRef.current = pollStatus; }, [pollStatus]);
 
   const startGeneration = useCallback(
     async (input: unknown, prompt: string) => {
@@ -175,7 +200,6 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       let creationId: string | null = null;
       if (userId && prompt) {
         try {
-          // Extract generation parameters from input
           const inputData = input as Record<string, unknown>;
           const duration = typeof inputData?.duration === "number" ? inputData.duration : undefined;
           const resolution = typeof inputData?.resolution === "string" ? inputData.resolution : undefined;
@@ -197,8 +221,6 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.error("[VideoQueue] Failed to save processing creation:", error);
           }
-          // Continue without creation tracking - generation can still proceed
-          // The video will be generated but won't appear in gallery history
         }
       }
 
@@ -206,7 +228,6 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       try {
         queueResult = await strategy.submitToQueue(input);
       } catch (error) {
-        // Queue submission threw - reset state and report error
         if (creationId && userId) {
           try {
             await persistence.updateToFailed(userId, creationId, error instanceof Error ? error.message : "Queue submission failed");
@@ -243,10 +264,12 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
         }
       }
 
-      pollingRef.current = setInterval(() => void pollStatus(), DEFAULT_POLL_INTERVAL_MS);
-      void pollStatus();
+      // Start polling: record start time, then poll immediately + on interval
+      pollStartTimeRef.current = Date.now();
+      pollingRef.current = setInterval(() => void pollStatusRef.current(), DEFAULT_POLL_INTERVAL_MS);
+      void pollStatusRef.current();
     },
-    [userId, scenario, persistence, strategy, creditCost, pollStatus, onError],
+    [userId, scenario, persistence, strategy, creditCost, onError],
   );
 
   return { isGenerating, startGeneration };

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

@@ -1,12 +1,10 @@
 import { providerRegistry } from "../../../../../infrastructure/services/provider-registry.service";
 import { extractResultUrl, type GenerationUrls, type GenerationResult } from "./generation-result.utils";
 import { QUEUE_STATUS } from "../../../../../domain/constants/queue-status.constants";
+import { DEFAULT_MAX_CONSECUTIVE_ERRORS } from "../../../../../infrastructure/constants/polling.constants";
 
 declare const __DEV__: boolean;
 
-/** Max consecutive transient errors before aborting */
-const MAX_CONSECUTIVE_ERRORS = 5;
-
 /**
  * Extract meaningful error message from various error formats.
  * Fal AI client throws ValidationError with empty .message but details in .body/.detail
@@ -14,12 +12,8 @@ const MAX_CONSECUTIVE_ERRORS = 5;
 function extractErrorMessage(err: unknown): string {
   if (!err) return "Generation failed";
 
-  // Standard Error with message
-  if (err instanceof Error && err.message && err.message.length > 0) {
-    return err.message;
-  }
-
-  // Fal AI ValidationError - has .body.detail array
+  // Fal AI ValidationError - has .body.detail array (check before instanceof Error
+  // because ValidationError may extend Error with empty .message)
   const errObj = err as Record<string, unknown>;
   if (errObj.body && typeof errObj.body === "object") {
     const body = errObj.body as Record<string, unknown>;
@@ -35,6 +29,11 @@ function extractErrorMessage(err: unknown): string {
     if (first?.msg) return first.msg;
   }
 
+  // Standard Error with message
+  if (err instanceof Error && err.message && err.message.length > 0) {
+    return err.message;
+  }
+
   // Fallback to string conversion
   const str = String(err);
   return str.length > 0 && str !== "[object Object]" ? str : "Generation failed";
@@ -96,15 +95,21 @@ export const pollQueueStatus = async (params: PollParams): Promise<void> => {
           await onError(errorMessage);
         }
       } else {
-        await onError("Generation failed");
+        // Try to extract error from FAL job logs (error-level log takes priority)
+        const logs = status.logs ?? [];
+        const errorLog = logs.findLast?.((l) => l.level === "error") ?? logs[logs.length - 1];
+        const failMessage =
+          errorLog?.message && errorLog.message !== "[object Object]"
+            ? errorLog.message
+            : "Generation failed";
+        await onError(failMessage);
       }
     }
   } catch (err) {
     consecutiveErrorsRef.current += 1;
-    const errorMessage = err instanceof Error ? err.message : "Generation failed";
+    const errorMessage = extractErrorMessage(err);
 
-    if (consecutiveErrorsRef.current >= MAX_CONSECUTIVE_ERRORS) {
-      // Too many consecutive errors - abort
+    if (consecutiveErrorsRef.current >= DEFAULT_MAX_CONSECUTIVE_ERRORS) {
       if (pollingRef.current) {
         clearInterval(pollingRef.current);
         pollingRef.current = null;
@@ -112,10 +117,9 @@ export const pollQueueStatus = async (params: PollParams): Promise<void> => {
       if (__DEV__) console.error("[VideoQueueGeneration] Max consecutive errors reached, aborting:", errorMessage);
       await onError(errorMessage);
     } else {
-      // Transient error - continue polling
       if (__DEV__) {
         console.warn(
-          `[VideoQueueGeneration] Transient poll error (${consecutiveErrorsRef.current}/${MAX_CONSECUTIVE_ERRORS}):`,
+          `[VideoQueueGeneration] Transient poll error (${consecutiveErrorsRef.current}/${DEFAULT_MAX_CONSECUTIVE_ERRORS}):`,
           errorMessage,
         );
       }