@umituz/react-native-ai-generation-content 1.61.62 → 1.61.64

package/package.json

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

package/src/core/index.ts

@@ -57,7 +57,7 @@ export type {
 // Segregated provider sub-interfaces
 export type { IAIProviderLifecycle } from "../domain/interfaces/provider-lifecycle.interface";
 export type { IAIProviderCapabilities } from "../domain/interfaces/provider-capabilities.interface";
-export type { IAIProviderJobManager } from "../domain/interfaces/provider-job-manager.interface";
+export type { IAIProviderJobManager } from "../domains/background/domain/interfaces/provider-job-manager.interface";
 export type { IAIProviderExecutor } from "../domain/interfaces/provider-executor.interface";
 export type { IAIProviderImageFeatures } from "../domain/interfaces/provider-image-features.interface";
 export type { IAIProviderVideoFeatures } from "../domain/interfaces/provider-video-features.interface";

package/src/domain/entities/index.ts

@@ -6,6 +6,6 @@
 export * from "./error.types";
 export * from "./generation.types";
 export * from "./polling.types";
-export * from "./job.types";
+export * from "../../domains/background/domain/entities/job.types";
 export * from "./processing-modes.types";
 export * from "./flow-config.types";

package/src/domain/interfaces/ai-provider.interface.ts

@@ -155,7 +155,7 @@ export interface VideoFeatureInputData {
 
 import type { IAIProviderLifecycle } from "./provider-lifecycle.interface";
 import type { IAIProviderCapabilities } from "./provider-capabilities.interface";
-import type { IAIProviderJobManager } from "./provider-job-manager.interface";
+import type { IAIProviderJobManager } from "../../domains/background/domain/interfaces/provider-job-manager.interface";
 import type { IAIProviderExecutor } from "./provider-executor.interface";
 import type { IAIProviderImageFeatures } from "./provider-image-features.interface";
 import type { IAIProviderVideoFeatures } from "./provider-video-features.interface";

package/src/domain/interfaces/index.ts

@@ -9,7 +9,7 @@ export * from "./app-services.interface";
 // Interface Segregation - Split provider interfaces
 export type { IAIProviderLifecycle } from "./provider-lifecycle.interface";
 export type { IAIProviderCapabilities } from "./provider-capabilities.interface";
-export type { IAIProviderJobManager } from "./provider-job-manager.interface";
+export type { IAIProviderJobManager } from "../../domains/background/domain/interfaces/provider-job-manager.interface";
 export type { IAIProviderExecutor } from "./provider-executor.interface";
 export type { IAIProviderImageFeatures } from "./provider-image-features.interface";
 export type { IAIProviderVideoFeatures } from "./provider-video-features.interface";

package/src/domains/background/domain/entities/index.ts

@@ -0,0 +1 @@
+export * from "./job.types";

package/src/domains/background/domain/interfaces/index.ts

@@ -0,0 +1 @@
+export * from "./provider-job-manager.interface";

package/src/{domain → domains/background/domain}/interfaces/provider-job-manager.interface.ts

@@ -3,7 +3,7 @@
  * Single Responsibility: Async job submission, status checking, and result retrieval
  */
 
-import type { JobSubmission, JobStatus } from "./ai-provider.interface";
+import type { JobSubmission, JobStatus } from "../../../../domain/interfaces/ai-provider.interface";
 
 export interface IAIProviderJobManager {
   /**

package/src/domains/background/domain/types/background-generation.types.ts

@@ -0,0 +1,28 @@
+import type {
+  BackgroundJob,
+  BackgroundQueueConfig,
+  JobExecutorConfig,
+} from "../entities/job.types";
+import type { executeDirectGeneration } from "../../infrastructure/executors/backgroundJobExecutor";
+
+export type { DirectExecutionResult } from "../../infrastructure/executors/backgroundJobExecutor";
+
+export interface UseBackgroundGenerationOptions<TInput, TResult>
+  extends Partial<BackgroundQueueConfig> {
+  readonly executor: JobExecutorConfig<TInput, TResult>;
+  readonly onJobComplete?: (job: BackgroundJob<TInput, TResult>) => void;
+  readonly onJobError?: (job: BackgroundJob<TInput, TResult>) => void;
+  readonly onAllComplete?: () => void;
+  readonly onProgress?: (progress: number) => void;
+}
+
+export interface UseBackgroundGenerationReturn<TInput, TResult> {
+  readonly startJob: (input: TInput, type: string) => Promise<string>;
+  readonly executeDirectly: (input: TInput) => ReturnType<typeof executeDirectGeneration<TInput, TResult>>;
+  readonly cancelJob: (id: string) => void;
+  readonly pendingJobs: BackgroundJob<TInput, TResult>[];
+  readonly activeJobCount: number;
+  readonly hasActiveJobs: boolean;
+  readonly isProcessing: boolean;
+  readonly progress: number;
+}

package/src/domains/background/infrastructure/executors/backgroundJobExecutor.ts

@@ -0,0 +1,105 @@
+import type { BackgroundJob, JobExecutorConfig } from "../../domain/entities/job.types";
+
+export interface DirectExecutionResult<TResult> {
+  readonly success: boolean;
+  readonly result?: TResult;
+  readonly error?: string;
+}
+
+interface DirectExecutionParams<TInput, TResult> {
+  input: TInput;
+  executor: JobExecutorConfig<TInput, TResult>;
+  onProgress?: (progress: number) => void;
+  setProgress: (progress: number) => void;
+  setIsProcessing: (isProcessing: boolean) => void;
+}
+
+export const executeDirectGeneration = async <TInput, TResult>(
+  params: DirectExecutionParams<TInput, TResult>,
+): Promise<DirectExecutionResult<TResult>> => {
+  const { input, executor, onProgress, setProgress, setIsProcessing } = params;
+
+  setIsProcessing(true);
+  setProgress(0);
+
+  try {
+    const result = await executor.execute(input, (p) => {
+      setProgress(p);
+      onProgress?.(p);
+    });
+
+    setProgress(100);
+    return { success: true, result };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    return { success: false, error: errorMsg };
+  } finally {
+    setIsProcessing(false);
+  }
+};
+
+interface QueuedExecutionParams<TInput, TResult> {
+  jobId: string;
+  input: TInput;
+  executor: JobExecutorConfig<TInput, TResult>;
+  updateJob: (params: { id: string; updates: Partial<BackgroundJob<TInput, TResult>> }) => void;
+  removeJob: (id: string) => void;
+  getJob: (id: string) => BackgroundJob<TInput, TResult> | undefined;
+  activeJobsRef: React.MutableRefObject<Set<string>>;
+  onJobComplete?: (job: BackgroundJob<TInput, TResult>) => void;
+  onJobError?: (job: BackgroundJob<TInput, TResult>) => void;
+  onAllComplete?: () => void;
+}
+
+export const executeQueuedJob = async <TInput, TResult>(
+  params: QueuedExecutionParams<TInput, TResult>,
+): Promise<void> => {
+  const {
+    jobId,
+    input,
+    executor,
+    updateJob,
+    removeJob,
+    getJob,
+    activeJobsRef,
+    onJobComplete,
+    onJobError,
+    onAllComplete,
+  } = params;
+
+  try {
+    updateJob({ id: jobId, updates: { status: "processing", progress: 10 } });
+
+    const result = await executor.execute(input, (p) => {
+      updateJob({ id: jobId, updates: { progress: p } });
+    });
+
+    updateJob({
+      id: jobId,
+      updates: { status: "completed", progress: 100, result, completedAt: new Date() },
+    });
+
+    const completedJob = getJob(jobId);
+    if (completedJob) {
+      await executor.onComplete?.(completedJob);
+      onJobComplete?.(completedJob);
+    }
+
+    removeJob(jobId);
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+
+    updateJob({ id: jobId, updates: { status: "failed", error: errorMsg, progress: 0 } });
+
+    const failedJob = getJob(jobId);
+    if (failedJob) {
+      await executor.onError?.(failedJob, error instanceof Error ? error : new Error(errorMsg));
+      onJobError?.(failedJob);
+    }
+  } finally {
+    activeJobsRef.current.delete(jobId);
+    if (activeJobsRef.current.size === 0) {
+      onAllComplete?.();
+    }
+  }
+};

package/src/{infrastructure → domains/background/infrastructure}/services/job-poller-factory.ts

@@ -3,7 +3,7 @@
  * Creates pre-configured job poller instances
  */
 
-import type { PollingConfig } from "../../domain/entities";
+import type { PollingConfig } from "../../../../domain/entities/polling.types";
 import type { PollJobOptions } from "./job-poller.types";
 import { pollJob } from "./job-poller.service";
 

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

@@ -4,7 +4,7 @@
  * Reports only real status - no fake progress
  */
 
-import { DEFAULT_POLLING_CONFIG } from "../../domain/entities";
+import { DEFAULT_POLLING_CONFIG } from "../../../../domain/entities/polling.types";
 import { calculatePollingInterval } from "../utils/polling-interval.util";
 import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
 import { validateResult } from "../utils/result-validator.util";

package/src/{infrastructure → domains/background/infrastructure}/services/job-poller.types.ts

@@ -2,8 +2,8 @@
  * Job Poller Type Definitions
  */
 
-import type { IAIProvider, JobStatus } from "../../domain/interfaces";
-import type { PollingConfig } from "../../domain/entities";
+import type { IAIProvider, JobStatus } from "../../../../domain/interfaces/ai-provider.interface";
+import type { PollingConfig } from "../../../../domain/entities/polling.types";
 
 export interface PollJobOptions {
   provider: IAIProvider;

package/src/{infrastructure → domains/background/infrastructure}/utils/polling-interval.util.ts

@@ -6,7 +6,7 @@
 import {
   DEFAULT_POLLING_CONFIG,
   type PollingConfig,
-} from "../../domain/entities";
+} from "../../../../domain/entities/polling.types";
 
 export interface IntervalOptions {
   attempt: number;

package/src/{infrastructure → domains/background/infrastructure}/utils/status-checker.util.ts

@@ -3,7 +3,7 @@
  * Checks job status responses for errors
  */
 
-import type { JobStatus, AILogEntry } from "../../domain/interfaces";
+import type { JobStatus, AILogEntry } from "../../../../domain/interfaces/ai-provider.interface";
 
 export interface StatusCheckResult {
   status: string;

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

@@ -0,0 +1,97 @@
+import { useCallback, useRef, useState } from "react";
+import { usePendingJobs } from "./use-pending-jobs";
+import { executeDirectGeneration, executeQueuedJob } from "../../infrastructure/executors/backgroundJobExecutor";
+import { DEFAULT_QUEUE_CONFIG } from "../../domain/entities/job.types";
+import type {
+  UseBackgroundGenerationOptions,
+  UseBackgroundGenerationReturn,
+} from "../../domain/types/background-generation.types";
+
+export type { DirectExecutionResult, UseBackgroundGenerationOptions, UseBackgroundGenerationReturn } from "../../domain/types/background-generation.types";
+
+export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
+  options: UseBackgroundGenerationOptions<TInput, TResult>,
+): UseBackgroundGenerationReturn<TInput, TResult> {
+  const config = { ...DEFAULT_QUEUE_CONFIG, ...options };
+  const activeJobsRef = useRef<Set<string>>(new Set());
+  const jobInputsRef = useRef<Map<string, { input: TInput; type: string }>>(
+    new Map(),
+  );
+
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [progress, setProgress] = useState(0);
+
+  const { jobs, addJobAsync, updateJob, removeJob, getJob } = usePendingJobs<
+    TInput,
+    TResult
+  >({
+    queryKey: config.queryKey,
+  });
+
+  const { executor, onProgress, onJobComplete, onJobError, onAllComplete } = options;
+
+  const executeDirectly = useCallback(
+    (input: TInput) =>
+      executeDirectGeneration({ input, executor, onProgress, setProgress, setIsProcessing }),
+    [executor, onProgress],
+  );
+
+  const executeJob = useCallback(
+    (jobId: string, input: TInput) =>
+      executeQueuedJob({
+        jobId,
+        input,
+        executor,
+        updateJob,
+        removeJob,
+        getJob,
+        activeJobsRef,
+        onJobComplete,
+        onJobError,
+        onAllComplete,
+      }),
+    [executor, onJobComplete, onJobError, onAllComplete, updateJob, removeJob, getJob],
+  );
+
+  const startJob = useCallback(
+    async (input: TInput, type: string): Promise<string> => {
+      const jobId = `job-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+
+      jobInputsRef.current.set(jobId, { input, type });
+
+      await addJobAsync({
+        id: jobId,
+        input,
+        type,
+        status: "queued",
+        progress: 0,
+      });
+
+      activeJobsRef.current.add(jobId);
+      void executeJob(jobId, input);
+
+      return jobId;
+    },
+    [addJobAsync, executeJob],
+  );
+
+  const cancelJob = useCallback(
+    (id: string) => {
+      activeJobsRef.current.delete(id);
+      jobInputsRef.current.delete(id);
+      removeJob(id);
+    },
+    [removeJob],
+  );
+
+  return {
+    startJob,
+    executeDirectly,
+    cancelJob,
+    pendingJobs: jobs,
+    activeJobCount: activeJobsRef.current.size,
+    hasActiveJobs: activeJobsRef.current.size > 0,
+    isProcessing,
+    progress,
+  };
+}

package/src/domains/creations/presentation/components/PendingJobsSection.tsx

@@ -6,7 +6,7 @@
 import React from "react";
 import { View, StyleSheet } from "react-native";
 import { AtomicText, useAppDesignTokens } from "@umituz/react-native-design-system";
-import type { BackgroundJob } from "../../../../domain/entities/job.types";
+import type { BackgroundJob } from "../../../background/domain/entities/job.types";
 import { PendingJobCard } from "../../../../presentation/components/PendingJobCard";
 
 export interface PendingJobsSectionProps {

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

@@ -0,0 +1,65 @@
+import { buildWizardInput } from "../../infrastructure/strategies";
+import type { WizardScenarioData } from "./wizard-generation.types";
+import type { Scenario } from "../../../../scenarios/domain/scenario.types";
+import type { GenerationAction } from "./wizard-state-machine";
+
+declare const __DEV__: boolean;
+
+interface ExecuteGenerationParams {
+  wizardData: WizardScenarioData;
+  scenario: Scenario;
+  isVideoMode: boolean;
+  isMountedRef: React.MutableRefObject<boolean>;
+  dispatch: React.Dispatch<GenerationAction>;
+  onError?: (error: string) => void;
+  videoGenerationFn: (input: any, prompt: string) => Promise<void>;
+  photoGenerationFn: (input: any, prompt: string) => Promise<void>;
+}
+
+export const executeWizardGeneration = async (params: ExecuteGenerationParams): Promise<void> => {
+  const {
+    wizardData,
+    scenario,
+    isVideoMode,
+    isMountedRef,
+    dispatch,
+    onError,
+    videoGenerationFn,
+    photoGenerationFn,
+  } = params;
+
+  try {
+    const input = await buildWizardInput(wizardData, scenario);
+
+    if (!isMountedRef.current) return;
+
+    if (!input) {
+      dispatch({ type: "ERROR", error: "Failed to build generation input" });
+      onError?.("Failed to build generation input");
+      return;
+    }
+
+    dispatch({ type: "START_GENERATION" });
+
+    if (__DEV__) {
+      console.log("[WizardGeneration] GENERATING -", isVideoMode ? "VIDEO" : "PHOTO");
+    }
+
+    const typedInput = input as { prompt?: string };
+    const generationFn = isVideoMode ? videoGenerationFn : photoGenerationFn;
+    await generationFn(input, typedInput.prompt || "");
+
+    if (isMountedRef.current) {
+      dispatch({ type: "COMPLETE" });
+    }
+  } catch (error: any) {
+    if (!isMountedRef.current) return;
+
+    const errorMsg = error?.message || "error.generation.unknown";
+    if (__DEV__) {
+      console.error("[WizardGeneration] Error:", errorMsg, error);
+    }
+    dispatch({ type: "ERROR", error: errorMsg });
+    onError?.(errorMsg);
+  }
+};

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

@@ -0,0 +1,35 @@
+export type GenerationStatus = "IDLE" | "PREPARING" | "GENERATING" | "ERROR" | "COMPLETED";
+
+export interface GenerationState {
+  status: GenerationStatus;
+  error?: string;
+}
+
+export type GenerationAction =
+  | { type: "START_PREPARATION" }
+  | { type: "START_GENERATION" }
+  | { type: "COMPLETE" }
+  | { type: "ERROR"; error: string }
+  | { type: "RESET" };
+
+export const generationReducer = (
+  state: GenerationState,
+  action: GenerationAction,
+): GenerationState => {
+  switch (action.type) {
+    case "START_PREPARATION":
+      return { status: "PREPARING" };
+    case "START_GENERATION":
+      return { status: "GENERATING" };
+    case "COMPLETE":
+      return { status: "COMPLETED" };
+    case "ERROR":
+      return { status: "ERROR", error: action.error };
+    case "RESET":
+      return { status: "IDLE" };
+    default:
+      return state;
+  }
+};
+
+export const INITIAL_STATE: GenerationState = { status: "IDLE" };

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

@@ -0,0 +1,13 @@
+import type { Creation } from "../../../../creations/domain/entities/Creation";
+
+export const isCreation = (result: unknown): result is Creation => {
+  if (!result || typeof result !== "object") return false;
+  const creation = result as Partial<Creation>;
+  return (
+    typeof creation.id === "string" &&
+    typeof creation.uri === "string" &&
+    typeof creation.type === "string" &&
+    creation.createdAt instanceof Date &&
+    typeof creation.isShared === "boolean"
+  );
+};

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

@@ -1,19 +1,10 @@
-/**
- * useVideoQueueGeneration Hook
- * Handles video generation via FAL queue with background support
- * - Submits to queue for non-blocking generation
- * - Polls for completion status
- * - Supports background generation (user can dismiss wizard)
- */
-
 import { useEffect, useRef, useCallback, useState } from "react";
-import { providerRegistry } from "../../../../../infrastructure/services/provider-registry.service";
-import { extractResultUrl, type FalResult, type GenerationUrls } from "./generation-result.utils";
-import { QUEUE_STATUS } from "../../../../../domain/constants/queue-status.constants";
+import { pollQueueStatus } from "./videoQueuePoller";
 import { DEFAULT_POLL_INTERVAL_MS } from "../../../../../infrastructure/constants/polling.constants";
 import type { CreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
 import type { WizardStrategy } from "../../infrastructure/strategies/wizard-strategy.types";
 import type { WizardScenarioData } from "./wizard-generation.types";
+import type { GenerationUrls } from "./generation-result.utils";
 
 declare const __DEV__: boolean;
 
@@ -31,9 +22,7 @@ export interface UseVideoQueueGenerationReturn {
   readonly startGeneration: (input: unknown, prompt: string) => Promise<void>;
 }
 
-export function useVideoQueueGeneration(
-  props: UseVideoQueueGenerationProps,
-): UseVideoQueueGenerationReturn {
+export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): UseVideoQueueGenerationReturn {
   const { userId, scenario, persistence, strategy, onSuccess, onError } = props;
 
   const creationIdRef = useRef<string | null>(null);
@@ -44,7 +33,6 @@ export function useVideoQueueGeneration(
   const isPollingRef = useRef(false);
   const [isGenerating, setIsGenerating] = useState(false);
 
-  // Cleanup polling on unmount
   useEffect(() => {
     return () => {
       if (pollingRef.current) {
@@ -74,7 +62,7 @@ export function useVideoQueueGeneration(
             videoUrl: urls.videoUrl,
           });
         } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateToCompleted error:", err);
+          if (__DEV__) console.error("[VideoQueueGeneration] updateToCompleted error:", err);
         }
       }
       resetRefs();
@@ -90,7 +78,7 @@ export function useVideoQueueGeneration(
         try {
           await persistence.updateToFailed(userId, creationId, errorMsg);
         } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateToFailed error:", err);
+          if (__DEV__) console.error("[VideoQueueGeneration] updateToFailed error:", err);
         }
       }
       resetRefs();
@@ -99,75 +87,52 @@ export function useVideoQueueGeneration(
     [userId, persistence, onError, resetRefs],
   );
 
-  const pollQueueStatus = useCallback(async () => {
-    // Guard against concurrent polls
-    if (isPollingRef.current) return;
-
+  const pollStatus = useCallback(async () => {
     const requestId = requestIdRef.current;
     const model = modelRef.current;
-    const provider = providerRegistry.getActiveProvider();
-    if (!requestId || !model || !provider) return;
-
-    isPollingRef.current = true;
-    try {
-      const status = await provider.getJobStatus(model, requestId);
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Poll:", status.status);
-
-      if (status.status === QUEUE_STATUS.COMPLETED || status.status === QUEUE_STATUS.FAILED) {
-        if (pollingRef.current) { clearInterval(pollingRef.current); pollingRef.current = null; }
-        if (status.status === QUEUE_STATUS.COMPLETED) {
-          try {
-            const result = await provider.getJobResult<FalResult>(model, requestId);
-            await handleComplete(extractResultUrl(result));
-          } catch (resultErr) {
-            // Handle errors when getting/extracting result (e.g., ValidationError, content policy)
-            const errorMessage = resultErr instanceof Error ? resultErr.message : "Generation failed";
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.error("[VideoQueueGeneration] Result error:", errorMessage);
-            }
-            await handleError(errorMessage);
-          }
-        } else {
-          await handleError("Generation failed");
-        }
-      }
-    } catch (err) {
-      // Handle polling errors - stop polling and show error to user
-      if (pollingRef.current) { clearInterval(pollingRef.current); pollingRef.current = null; }
-      const errorMessage = err instanceof Error ? err.message : "Generation failed";
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[VideoQueueGeneration] Poll error:", errorMessage);
-      }
-      await handleError(errorMessage);
-    } finally {
-      isPollingRef.current = false;
-    }
+    if (!requestId || !model) return;
+
+    await pollQueueStatus({
+      requestId,
+      model,
+      isPollingRef,
+      pollingRef,
+      onComplete: handleComplete,
+      onError: handleError,
+    });
   }, [handleComplete, handleError]);
 
   const startGeneration = useCallback(
     async (input: unknown, prompt: string) => {
-      if (!strategy.submitToQueue) { onError?.("Queue submission not available"); return; }
+      if (!strategy.submitToQueue) {
+        onError?.("Queue submission not available");
+        return;
+      }
       if (isGeneratingRef.current) return;
+
       isGeneratingRef.current = true;
       setIsGenerating(true);
 
-      // Save to Firestore FIRST (enables background visibility)
       let creationId: string | null = null;
       if (userId && prompt) {
         try {
           creationId = await persistence.saveAsProcessing(userId, {
-            scenarioId: scenario.id, scenarioTitle: scenario.title || scenario.id, prompt,
+            scenarioId: scenario.id,
+            scenarioTitle: scenario.title || scenario.id,
+            prompt,
           });
           creationIdRef.current = creationId;
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Saved:", creationId);
+          if (__DEV__) console.log("[VideoQueueGeneration] Saved:", creationId);
         } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] save error:", err);
+          if (__DEV__) console.error("[VideoQueueGeneration] save error:", err);
         }
       }
 
       const queueResult = await strategy.submitToQueue(input);
       if (!queueResult.success || !queueResult.requestId || !queueResult.model) {
-        if (creationId && userId) await persistence.updateToFailed(userId, creationId, queueResult.error || "Queue submission failed");
+        if (creationId && userId) {
+          await persistence.updateToFailed(userId, creationId, queueResult.error || "Queue submission failed");
+        }
         setIsGenerating(false);
         onError?.(queueResult.error || "Queue submission failed");
         return;
@@ -176,21 +141,19 @@ export function useVideoQueueGeneration(
       requestIdRef.current = queueResult.requestId;
       modelRef.current = queueResult.model;
 
-      // Update with requestId for background polling
       if (creationId && userId) {
         try {
           await persistence.updateRequestId(userId, creationId, queueResult.requestId, queueResult.model);
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Updated requestId:", queueResult.requestId);
+          if (__DEV__) console.log("[VideoQueueGeneration] Updated requestId:", queueResult.requestId);
         } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateRequestId error:", err);
+          if (__DEV__) console.error("[VideoQueueGeneration] updateRequestId error:", err);
         }
       }
 
-      pollingRef.current = setInterval(() => void pollQueueStatus(), DEFAULT_POLL_INTERVAL_MS);
-      // Immediate poll to avoid waiting for first interval tick
-      void pollQueueStatus();
+      pollingRef.current = setInterval(() => void pollStatus(), DEFAULT_POLL_INTERVAL_MS);
+      void pollStatus();
     },
-    [userId, scenario, persistence, strategy, pollQueueStatus, onError],
+    [userId, scenario, persistence, strategy, pollStatus, onError],
   );
 
   return { isGenerating, startGeneration };