@umituz/react-native-ai-generation-content 1.65.7 → 1.65.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.65.7",
+  "version": "1.65.9",
   "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

@@ -52,7 +52,7 @@ export function useAIFeatureGate(options: AIFeatureGateOptions): AIFeatureGateRe
     hasSubscription: isPremium,
     creditBalance,
     requiredCredits: creditCost,
-    onShowPaywall: openPaywall,
+    onShowPaywall: () => openPaywall(),
     isCreditsLoaded,
   });
 

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

@@ -10,6 +10,56 @@ import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.uti
 import { validateResult } from "../utils/result-validator.util";
 import type { PollJobOptions, PollJobResult } from "./job-poller.types";
 
+declare const __DEV__: boolean;
+
+/**
+ * Wraps a promise with abort signal support
+ * Rejects if signal is aborted before promise resolves
+ */
+function withAbortSignal<T>(
+  promise: Promise<T>,
+  signal: AbortSignal | undefined,
+  timeoutMs?: number,
+): Promise<T> {
+  if (!signal && !timeoutMs) {
+    return promise;
+  }
+
+  return new Promise<T>((resolve, reject) => {
+    // Handle abort signal
+    if (signal?.aborted) {
+      reject(new Error("Operation aborted"));
+      return;
+    }
+
+    const abortHandler = () => {
+      reject(new Error("Operation aborted"));
+    };
+
+    signal?.addEventListener("abort", abortHandler, { once: true });
+
+    // Handle timeout
+    let timeoutId: NodeJS.Timeout | undefined;
+    if (timeoutMs) {
+      timeoutId = setTimeout(() => {
+        reject(new Error(`Operation timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+    }
+
+    promise
+      .then((result) => {
+        signal?.removeEventListener("abort", abortHandler);
+        if (timeoutId) clearTimeout(timeoutId);
+        resolve(result);
+      })
+      .catch((error) => {
+        signal?.removeEventListener("abort", abortHandler);
+        if (timeoutId) clearTimeout(timeoutId);
+        reject(error);
+      });
+  });
+}
+
 /**
  * Poll job until completion with exponential backoff
  * Only reports 100% on actual completion
@@ -60,7 +110,12 @@ export async function pollJob<T = unknown>(
     }
 
     try {
-      const status = await provider.getJobStatus(model, requestId);
+      // Wrap provider calls with abort signal support and timeout (30s default)
+      const status = await withAbortSignal(
+        provider.getJobStatus(model, requestId),
+        signal,
+        30000,
+      );
       onStatusChange?.(status);
 
       const statusCheck = checkStatusForErrors(status);
@@ -77,7 +132,12 @@ export async function pollJob<T = unknown>(
       consecutiveTransientErrors = 0;
 
       if (isJobComplete(status)) {
-        const result = await provider.getJobResult<T>(model, requestId);
+        // Wrap result retrieval with abort signal support and timeout (60s for larger results)
+        const result = await withAbortSignal(
+          provider.getJobResult<T>(model, requestId),
+          signal,
+          60000,
+        );
 
         const validation = validateResult(result);
         if (!validation.isValid) {
@@ -98,11 +158,29 @@ export async function pollJob<T = unknown>(
           elapsedMs: Date.now() - startTime,
         };
       }
-    } catch {
+    } catch (error) {
       consecutiveTransientErrors++;
 
+      if (__DEV__) {
+        console.warn("[JobPoller] Transient error during polling", {
+          attempt: attempt + 1,
+          requestId,
+          model,
+          consecutiveErrors: consecutiveTransientErrors,
+          error: error instanceof Error ? error.message : String(error),
+          code: (error as { code?: string })?.code,
+        });
+      }
+
       // Check if we've hit max consecutive transient errors
       if (maxConsecutiveErrors && consecutiveTransientErrors >= maxConsecutiveErrors) {
+        if (__DEV__) {
+          console.error("[JobPoller] Max consecutive errors reached", {
+            maxConsecutiveErrors,
+            requestId,
+            model,
+          });
+        }
         return {
           success: false,
           error: new Error(`Too many consecutive errors (${consecutiveTransientErrors})`),

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

@@ -2,10 +2,7 @@
  * Polling Interval Calculator
  */
 
-import {
-  DEFAULT_POLLING_CONFIG,
-  type PollingConfig,
-} from "../../../../domain/entities/polling.types";
+import type { PollingConfig } from "../../../../domain/entities/polling.types";
 
 export interface IntervalOptions {
   attempt: number;

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

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useRef, useState, useMemo } from "react";
 import { usePendingJobs } from "./use-pending-jobs";
 import { executeDirectGeneration, executeQueuedJob } from "../../infrastructure/executors/backgroundJobExecutor";
 import { DEFAULT_QUEUE_CONFIG } from "../../domain/entities/job.types";
@@ -85,13 +85,23 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
     [removeJob],
   );
 
+  // Calculate active jobs from TanStack Query state (not ref) for reactivity
+  // Active jobs are those currently processing or queued
+  const activeJobs = useMemo(
+    () => jobs.filter((job) => job.status === "processing" || job.status === "queued"),
+    [jobs]
+  );
+
+  const activeJobCount = activeJobs.length;
+  const hasActiveJobs = activeJobCount > 0;
+
   return {
     startJob,
     executeDirectly,
     cancelJob,
     pendingJobs: jobs,
-    activeJobCount: activeJobsRef.current.size,
-    hasActiveJobs: activeJobsRef.current.size > 0,
+    activeJobCount,
+    hasActiveJobs,
     isProcessing,
     progress,
   };

package/src/domains/creations/infrastructure/repositories/CreationsFetcher.ts

@@ -144,7 +144,7 @@ export class CreationsFetcher {
                 if (__DEV__) {
                     console.error("[CreationsFetcher] Realtime subscription error:", {
                         error: error.message,
-                        code: (error as any).code,
+                        code: (error as { code?: string }).code,
                         userId,
                     });
                 }

package/src/domains/creations/infrastructure/repositories/CreationsRepository.ts

@@ -1,4 +1,3 @@
-declare const __DEV__: boolean;
 
 import { BaseRepository, FirestorePathResolver } from "@umituz/react-native-firebase";
 import type {

package/src/domains/creations/infrastructure/repositories/creation-delete.operations.ts

@@ -5,6 +5,8 @@
 import { updateDoc, deleteDoc } from "firebase/firestore";
 import { type FirestorePathResolver } from "@umituz/react-native-firebase";
 
+declare const __DEV__: boolean;
+
 /**
  * Soft deletes a creation
  */
@@ -14,12 +16,31 @@ export async function deleteCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
+  if (!docRef) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Cannot delete: Invalid document reference", {
+        userId,
+        creationId,
+      });
+    }
+    return false;
+  }
 
   try {
     await updateDoc(docRef, { deletedAt: new Date() });
+    if (__DEV__) {
+      console.log("[CreationDelete] Soft deleted successfully", { userId, creationId });
+    }
     return true;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Soft delete failed", {
+        userId,
+        creationId,
+        error: error instanceof Error ? error.message : String(error),
+        code: (error as { code?: string })?.code,
+      });
+    }
     return false;
   }
 }
@@ -33,12 +54,31 @@ export async function hardDeleteCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
+  if (!docRef) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Cannot hard delete: Invalid document reference", {
+        userId,
+        creationId,
+      });
+    }
+    return false;
+  }
 
   try {
     await deleteDoc(docRef);
+    if (__DEV__) {
+      console.log("[CreationDelete] Hard deleted successfully", { userId, creationId });
+    }
     return true;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Hard delete failed", {
+        userId,
+        creationId,
+        error: error instanceof Error ? error.message : String(error),
+        code: (error as { code?: string })?.code,
+      });
+    }
     return false;
   }
 }
@@ -52,12 +92,31 @@ export async function restoreCreation(
   creationId: string
 ): Promise<boolean> {
   const docRef = pathResolver.getDocRef(userId, creationId);
-  if (!docRef) return false;
+  if (!docRef) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Cannot restore: Invalid document reference", {
+        userId,
+        creationId,
+      });
+    }
+    return false;
+  }
 
   try {
     await updateDoc(docRef, { deletedAt: null });
+    if (__DEV__) {
+      console.log("[CreationDelete] Restored successfully", { userId, creationId });
+    }
     return true;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.error("[CreationDelete] Restore failed", {
+        userId,
+        creationId,
+        error: error instanceof Error ? error.message : String(error),
+        code: (error as { code?: string })?.code,
+      });
+    }
     return false;
   }
 }

package/src/domains/creations/presentation/hooks/creation-validators.ts

@@ -14,7 +14,6 @@ import {
 } from "../../domain/constants";
 import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
 
-declare const __DEV__: boolean;
 
 export interface ValidationResult {
   isValid: boolean;

package/src/domains/generation/infrastructure/flow/use-flow-store.types.ts

@@ -4,7 +4,6 @@
 
 import type {
   FlowState,
-  FlowActions,
   StepDefinition,
 } from "../../../../domain/entities/flow-config.types";
 

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

@@ -15,7 +15,7 @@ import { extractPrompt, extractDuration, extractAspectRatio, extractResolution }
 import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
 import { getVideoFeatureType } from "./video-generation.utils";
 import type { WizardVideoInput, CreateVideoStrategyOptions } from "./video-generation.types";
-import { validatePhotoCount } from "./video-generation.types";
+import { validatePhotoCount, validateWizardVideoInput } from "./video-generation.types";
 
 declare const __DEV__: boolean;
 
@@ -76,7 +76,8 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
 
   return {
     execute: async (input: unknown) => {
-      const videoInput = input as WizardVideoInput;
+      // Runtime validation with descriptive errors
+      const videoInput = validateWizardVideoInput(input);
 
       const result = await executeVideoFeature(videoFeatureType, {
         sourceImageBase64: videoInput.sourceImageBase64,
@@ -97,7 +98,8 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
     },
 
     submitToQueue: async (input: unknown) => {
-      const videoInput = input as WizardVideoInput;
+      // Runtime validation with descriptive errors
+      const videoInput = validateWizardVideoInput(input);
 
       const result = await submitVideoFeatureToQueue(videoFeatureType, {
         sourceImageBase64: videoInput.sourceImageBase64,

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.types.ts

@@ -59,3 +59,87 @@ export function validatePhotoCount(
 
   return { isValid: true };
 }
+
+/**
+ * Type guard for WizardVideoInput
+ * Validates runtime input and provides type safety
+ */
+export function isWizardVideoInput(input: unknown): input is WizardVideoInput {
+  if (!input || typeof input !== "object") {
+    return false;
+  }
+
+  const obj = input as Record<string, unknown>;
+
+  // prompt is required
+  if (typeof obj.prompt !== "string" || obj.prompt.length === 0) {
+    return false;
+  }
+
+  // Optional fields validation
+  if (obj.sourceImageBase64 !== undefined && typeof obj.sourceImageBase64 !== "string") {
+    return false;
+  }
+
+  if (obj.targetImageBase64 !== undefined && typeof obj.targetImageBase64 !== "string") {
+    return false;
+  }
+
+  if (obj.duration !== undefined && typeof obj.duration !== "number") {
+    return false;
+  }
+
+  if (obj.aspectRatio !== undefined && typeof obj.aspectRatio !== "string") {
+    return false;
+  }
+
+  if (obj.resolution !== undefined && typeof obj.resolution !== "string") {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Validates and casts input to WizardVideoInput
+ * Throws descriptive error if validation fails
+ */
+export function validateWizardVideoInput(input: unknown): WizardVideoInput {
+  if (!isWizardVideoInput(input)) {
+    const errors: string[] = [];
+
+    if (!input || typeof input !== "object") {
+      throw new Error("Invalid input: expected object");
+    }
+
+    const obj = input as Record<string, unknown>;
+
+    if (typeof obj.prompt !== "string" || obj.prompt.length === 0) {
+      errors.push("prompt (string, required)");
+    }
+
+    if (obj.sourceImageBase64 !== undefined && typeof obj.sourceImageBase64 !== "string") {
+      errors.push("sourceImageBase64 (string, optional)");
+    }
+
+    if (obj.targetImageBase64 !== undefined && typeof obj.targetImageBase64 !== "string") {
+      errors.push("targetImageBase64 (string, optional)");
+    }
+
+    if (obj.duration !== undefined && typeof obj.duration !== "number") {
+      errors.push("duration (number, optional)");
+    }
+
+    if (obj.aspectRatio !== undefined && typeof obj.aspectRatio !== "string") {
+      errors.push("aspectRatio (string, optional)");
+    }
+
+    if (obj.resolution !== undefined && typeof obj.resolution !== "string") {
+      errors.push("resolution (string, optional)");
+    }
+
+    throw new Error(`Invalid WizardVideoInput: ${errors.join(", ")}`);
+  }
+
+  return input;
+}

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

@@ -1,19 +1,18 @@
 import { buildWizardInput } from "../../infrastructure/strategies";
 import type { WizardScenarioData } from "./wizard-generation.types";
-import type { Scenario } from "../../../../scenarios/domain/scenario.types";
 import type { GenerationAction } from "./generationStateMachine";
 
 declare const __DEV__: boolean;
 
 interface ExecuteGenerationParams {
-  wizardData: WizardScenarioData;
-  scenario: Scenario;
+  wizardData: Record<string, unknown>;
+  scenario: WizardScenarioData;
   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>;
+  videoGenerationFn: (input: unknown, prompt: string) => Promise<void>;
+  photoGenerationFn: (input: unknown, prompt: string) => Promise<void>;
 }
 
 export const executeWizardGeneration = async (params: ExecuteGenerationParams): Promise<void> => {
@@ -52,10 +51,10 @@ export const executeWizardGeneration = async (params: ExecuteGenerationParams):
     if (isMountedRef.current) {
       dispatch({ type: "COMPLETE" });
     }
-  } catch (error: any) {
+  } catch (error: unknown) {
     if (!isMountedRef.current) return;
 
-    const errorMsg = error?.message || "error.generation.unknown";
+    const errorMsg = (error instanceof Error ? error.message : String(error)) || "error.generation.unknown";
     if (__DEV__) {
       console.error("[WizardGeneration] Error:", errorMsg, error);
     }

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

@@ -46,7 +46,7 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       if (creationId && userId && (urls.videoUrl || urls.imageUrl)) {
         try {
           await persistence.updateToCompleted(userId, creationId, {
-            uri: urls.videoUrl || urls.imageUrl,
+            uri: (urls.videoUrl || urls.imageUrl) ?? "",
             imageUrl: urls.imageUrl,
             videoUrl: urls.videoUrl,
           });
@@ -123,7 +123,7 @@ export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): Us
       requestIdRef.current = queueResult.requestId;
       modelRef.current = queueResult.model;
 
-      if (creationId && userId) {
+      if (creationId && userId && queueResult.requestId && queueResult.model) {
         try {
           await persistence.updateRequestId(userId, creationId, queueResult.requestId, queueResult.model);
         } catch {}

package/src/domains/image-to-video/domain/types/config.types.ts

@@ -5,6 +5,7 @@
 
 import type { ImageToVideoResult } from "./image-to-video.types";
 import type { ImageToVideoFormState } from "./form.types";
+import type { ImageToVideoGenerationStartData, ImageToVideoCreationData } from "./image-to-video-callbacks.types";
 
 export interface ImageToVideoCallbacks {
   onGenerate: (formState: ImageToVideoFormState) => Promise<void>;
@@ -13,6 +14,8 @@ export interface ImageToVideoCallbacks {
   onShowPaywall?: (cost: number) => void;
   onSuccess?: (result: ImageToVideoResult) => void;
   onError?: (error: string) => void;
+  onGenerationStart?: (data: ImageToVideoGenerationStartData) => Promise<void>;
+  onCreationSave?: (data: ImageToVideoCreationData) => Promise<void>;
 }
 
 export interface ImageToVideoFormConfig {

package/src/domains/image-to-video/infrastructure/services/image-to-video-executor.ts

@@ -14,6 +14,9 @@ import type { ImageToVideoRequest, ImageToVideoResult } from "../../domain/types
 import { env } from "../../../../infrastructure/config/env.config";
 import type { ExecuteImageToVideoOptions } from "./image-to-video-executor.types";
 
+// Export types
+export type { ExecuteImageToVideoOptions };
+
 const STATUS_PROGRESS: Record<string, number> = {
   queued: 10,
   in_queue: 15,
@@ -41,17 +44,17 @@ class ImageToVideoExecutor extends BaseExecutor<
     input: Record<string, unknown>,
     onProgress?: (progress: number) => void,
   ): Promise<unknown> {
-    this.logInfo("Starting provider.subscribe()...");
+    this.log("info", "Starting provider.subscribe()...");
 
     const result = await provider.subscribe(model, input, {
       onQueueUpdate: (status: { status: string; queuePosition?: number }) => {
-        this.logInfo(`Queue: ${status.status}, pos: ${status.queuePosition}`);
+        this.log("info", `Queue: ${status.status}, pos: ${status.queuePosition}`);
         onProgress?.(STATUS_PROGRESS[status.status.toLowerCase()] ?? 30);
       },
       timeoutMs: env.generationVideoTimeoutMs,
     });
 
-    this.logInfo(`Complete, keys: ${result ? Object.keys(result as object) : "null"}`);
+    this.log("info", `Complete, keys: ${result ? Object.keys(result as object) : "null"}`);
     checkFalApiError(result);
     return result;
   }

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

@@ -1,7 +1,7 @@
 import { executeImageToVideo } from "../../infrastructure/services";
 import type { GenerationStrategy } from "../../../../presentation/hooks/generation";
 import type {
-  ImageToVideoConfig,
+  ImageToVideoFeatureConfig,
   ImageToVideoCallbacks,
   ImageToVideoResult,
   ImageToVideoOptions,
@@ -17,8 +17,8 @@ interface VideoGenerationInput {
 }
 
 interface CreateStrategyParams {
-  config: ImageToVideoConfig;
-  callbacks: ImageToVideoCallbacks;
+  config: ImageToVideoFeatureConfig;
+  callbacks?: ImageToVideoCallbacks;
   buildInput: ImageToVideoInputBuilder;
   extractResult?: ImageToVideoResultExtractor;
   userId: string;
@@ -30,22 +30,21 @@ interface CreateStrategyParams {
 export const createImageToVideoStrategy = (
   params: CreateStrategyParams,
 ): GenerationStrategy<VideoGenerationInput, ImageToVideoResult> => {
-  const { config, callbacks, buildInput, extractResult, userId, currentPrompt, creationIdRef, updateState } = params;
+  const { config, callbacks, buildInput, extractResult, userId, creationIdRef, updateState } = params;
 
   return {
     execute: async (input) => {
       creationIdRef.current = input.creationId;
 
-      callbacks.onGenerationStart?.({
+      callbacks?.onGenerationStart?.({
         creationId: input.creationId,
         type: "image-to-video",
-        imageUrl: input.imageUrl,
-        prompt: input.prompt,
+        imageUri: input.imageUrl,
         metadata: input.options as Record<string, unknown> | undefined,
       }).catch(() => {});
 
       const result = await executeImageToVideo(
-        { imageUrl: input.imageUrl, prompt: input.prompt, userId, options: input.options },
+        { imageUri: input.imageUrl, userId, motionPrompt: input.prompt, options: input.options },
         { model: config.model, buildInput, extractResult },
       );
 
@@ -61,15 +60,15 @@ export const createImageToVideoStrategy = (
         thumbnailUrl: result.thumbnailUrl,
       };
     },
-    getCreditCost: () => config.creditCost,
+    getCreditCost: () => config.creditCost ?? 0,
     save: async (result) => {
       if (result.success && result.videoUrl && creationIdRef.current) {
-        await callbacks.onCreationSave?.({
+        await callbacks?.onCreationSave?.({
           creationId: creationIdRef.current,
           type: "image-to-video",
           videoUrl: result.videoUrl,
           thumbnailUrl: result.thumbnailUrl,
-          prompt: currentPrompt,
+          imageUri: "",
         });
       }
     },

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

@@ -24,8 +24,8 @@ export interface UseFormStateReturn {
 function createInitialState(defaults: ImageToVideoFormDefaults): ImageToVideoFormState {
   return {
     selectedImages: [],
-    animationStyle: defaults.animationStyle,
-    duration: defaults.duration,
+    animationStyle: defaults.animationStyle ?? "none",
+    duration: defaults.duration ?? 3,
     motionPrompt: "",
   };
 }

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

@@ -1,9 +1,9 @@
 /**
  * Generation Hook for Image-to-Video
- * Manages generation state and execution
+ * Manages generation state and execution with abort support
  */
 
-import { useState, useCallback, useMemo } from "react";
+import { useState, useCallback, useMemo, useRef, useEffect } from "react";
 import type {
   ImageToVideoFormState,
   ImageToVideoGenerationState,
@@ -36,20 +36,46 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
     INITIAL_GENERATION_STATE
   );
 
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const isMountedRef = useRef(true);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+
+  // Stabilize callbacks to prevent unnecessary re-renders
+  const onErrorRef = useRef(callbacks.onError);
+  const onGenerateRef = useRef(callbacks.onGenerate);
+
+  useEffect(() => {
+    onErrorRef.current = callbacks.onError;
+    onGenerateRef.current = callbacks.onGenerate;
+  }, [callbacks.onError, callbacks.onGenerate]);
+
   const setProgress = useCallback((progress: number) => {
+    if (!isMountedRef.current) return;
     setGenerationState((prev) => ({ ...prev, progress }));
   }, []);
 
   const setError = useCallback((error: string | null) => {
+    if (!isMountedRef.current) return;
     setGenerationState((prev) => ({ ...prev, error, isGenerating: false }));
   }, []);
 
   const handleGenerate = useCallback(async () => {
     if (formState.selectedImages.length === 0) {
-      callbacks.onError?.("No images selected");
+      onErrorRef.current?.("No images selected");
       return;
     }
 
+    // Create new AbortController for this generation
+    abortControllerRef.current = new AbortController();
+
     setGenerationState({
       isGenerating: true,
       progress: 0,
@@ -57,18 +83,25 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
     });
 
     try {
-      await callbacks.onGenerate(formState);
+      await onGenerateRef.current(formState);
+
+      if (!isMountedRef.current || abortControllerRef.current.signal.aborted) return;
+
       setGenerationState((prev) => ({ ...prev, isGenerating: false, progress: 100 }));
     } catch (error) {
+      if (!isMountedRef.current || abortControllerRef.current.signal.aborted) return;
+
       const errorMessage = error instanceof Error ? error.message : String(error);
       setGenerationState({
         isGenerating: false,
         progress: 0,
         error: errorMessage,
       });
-      callbacks.onError?.(errorMessage);
+      onErrorRef.current?.(errorMessage);
+    } finally {
+      abortControllerRef.current = null;
     }
-  }, [formState, callbacks]);
+  }, [formState]);
 
   const isReady = useMemo(
     () => formState.selectedImages.length > 0 && !generationState.isGenerating,

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

@@ -1,11 +1,12 @@
 import { useState, useCallback, useMemo, useRef } from "react";
 import { useGenerationOrchestrator } from "../../../../presentation/hooks/generation";
 import { createImageToVideoStrategy } from "./imageToVideoStrategy";
-import type {
-  UseImageToVideoFeatureProps,
-  UseImageToVideoFeatureReturn,
+import type { ImageToVideoCallbacks } from "../../domain/types";
+import {
   INITIAL_STATE,
   DEFAULT_ALERT_MESSAGES,
+  type UseImageToVideoFeatureProps,
+  type UseImageToVideoFeatureReturn,
 } from "./image-to-video-feature.types";
 
 export type {
@@ -26,7 +27,7 @@ export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseI
     () =>
       createImageToVideoStrategy({
         config,
-        callbacks,
+        callbacks: callbacks as ImageToVideoCallbacks | undefined,
         buildInput: config.buildInput,
         extractResult: config.extractResult,
         userId,
@@ -40,14 +41,17 @@ export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseI
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages: DEFAULT_ALERT_MESSAGES,
-    onCreditsExhausted: () => callbacks.onShowPaywall?.(config.creditCost ?? 0),
-    onSuccess: (result) => {
-      config.onProcessingComplete?.();
-      callbacks.onGenerate?.(result);
+    onCreditsExhausted: () => callbacks?.onShowPaywall?.(config.creditCost ?? 0),
+    onSuccess: (result: unknown) => {
+      const typedResult = result as { success: boolean; videoUrl?: string; thumbnailUrl?: string };
+      if (typedResult.success && typedResult.videoUrl) {
+        config.onProcessingComplete?.(typedResult);
+        callbacks?.onGenerate?.(typedResult);
+      }
     },
     onError: (err) => {
-      config.onProcessingError?.(err.message);
-      callbacks.onError?.(err.message);
+      config.onError?.(err.message);
+      callbacks?.onError?.(err.message);
     },
   });
 
@@ -60,8 +64,8 @@ export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseI
   }, []);
 
   const generate = useCallback(
-    async (params?: any) => {
-      const imageUri = params?.imageUri || state.imageUri;
+    async (params?: unknown): Promise<{ success: boolean; videoUrl?: string; thumbnailUrl?: string; error?: string }> => {
+      const imageUri = (params && typeof params === "object" && "imageUri" in params ? (params as { imageUri?: string }).imageUri : undefined) || state.imageUri;
       if (!imageUri) {
         const error = "Image is required";
         setState((prev) => ({ ...prev, error }));
@@ -74,11 +78,12 @@ export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseI
         const result = await orchestrator.generate({
           imageUrl: imageUri,
           prompt: state.motionPrompt || "",
-          options: params,
+          options: params && typeof params === "object" ? params : undefined,
           creationId: `image-to-video-${Date.now()}`,
         });
         setState((prev) => ({ ...prev, isProcessing: false }));
-        return result;
+        const typedResult = result as { success: boolean; videoUrl?: string; thumbnailUrl?: string; error?: string };
+        return typedResult;
       } catch (error) {
         const message = error instanceof Error ? error.message : "Generation failed";
         setState((prev) => ({ ...prev, isProcessing: false, error: message }));

package/src/domains/prompts/infrastructure/services/ImagePromptBuilder.ts

@@ -11,7 +11,10 @@ import {
   ANTI_REALISM_SEGMENTS,
   ANATOMY_NEGATIVE_SEGMENTS,
 } from "../../domain/entities/image-prompt-segments";
-import type { ImagePromptResult, ImagePromptBuilderOptions } from "./image-prompt-builder.types";
+import type { ImagePromptResult, ImagePromptBuilderOptions, AnimeSelfiePromptResult } from "./image-prompt-builder.types";
+
+// Export types
+export type { ImagePromptResult, ImagePromptBuilderOptions, AnimeSelfiePromptResult };
 
 export class ImagePromptBuilder {
   private positiveSegments: string[] = [];
@@ -96,3 +99,6 @@ export class ImagePromptBuilder {
     };
   }
 }
+
+// Export utility functions
+export { createAnimeSelfiePrompt, createStyleTransferPrompt } from "../utils/prompt-creators.util";

package/src/domains/text-to-image/presentation/hooks/useFormState.ts

@@ -13,10 +13,9 @@ import type {
   TextToImageFormActions,
   TextToImageFormDefaults,
 } from "../../domain/types/form.types";
-import { DEFAULT_FORM_VALUES } from "../../domain/constants/options.constants";
 
 export interface UseFormStateOptions {
-  defaults: Required<TextToImageFormDefaults>;
+  defaults: TextToImageFormDefaults;
 }
 
 export interface UseFormStateReturn {

package/src/domains/text-to-image/presentation/hooks/useGeneration.ts

@@ -72,7 +72,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
 
   // Use orchestrator
   const { generate, isGenerating, error } = useGenerationOrchestrator(strategy, {
-    userId,
+    userId: userId ?? undefined,
     alertMessages: DEFAULT_ALERT_MESSAGES,
     onCreditsExhausted: () => callbacks.onCreditsRequired?.(totalCost),
     onSuccess: (result) => {
@@ -132,7 +132,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
   return {
     generationState: {
       isGenerating,
-      error: error?.message === undefined ? null : error.message,
+      error: error?.message ?? null,
     },
     totalCost,
     handleGenerate,

package/src/domains/text-to-image/presentation/screens/TextToImageWizardFlow.tsx

@@ -10,7 +10,6 @@ import { GenericWizardFlow } from "../../../../domains/generation/wizard/present
 import { TEXT_TO_IMAGE_WIZARD_CONFIG } from "../../../../domains/generation/wizard/configs";
 import { useAIFeatureGate } from "../../../../domains/access-control";
 import {
-  createDefaultAlerts,
   createScenarioData,
   useWizardFlowHandlers,
   AutoSkipPreview,

package/src/domains/text-to-video/infrastructure/services/text-to-video-executor.ts

@@ -55,7 +55,7 @@ class TextToVideoExecutor extends BaseExecutor<
     input: Record<string, unknown>,
     onProgress?: (progress: number) => void,
   ): Promise<unknown> {
-    this.logInfo("Starting provider.run()...");
+    this.log("info","Starting provider.run()...");
 
     // Provider reports real progress via callback
     const result = await provider.run(model, input, {
@@ -68,7 +68,7 @@ class TextToVideoExecutor extends BaseExecutor<
       },
     });
 
-    this.logInfo("provider.run() completed");
+    this.log("info","provider.run() completed");
     return result;
   }
 

package/src/infrastructure/executors/base-executor.ts

@@ -21,7 +21,7 @@ export abstract class BaseExecutor<TRequest, TResult, TOutput> {
     options: BaseExecutorOptions<TRequest, TOutput>,
   ): Promise<Result<TResult, string>> {
     const providerResult = this.getProvider();
-    if (providerResult.error) return failure(providerResult.error);
+    if (providerResult.error || !providerResult.provider) return failure(providerResult.error);
 
     const validationError = this.validateRequest(request);
     if (validationError) {
@@ -88,7 +88,7 @@ export abstract class BaseExecutor<TRequest, TResult, TOutput> {
     return success(this.transformResult(extracted as TOutput));
   }
 
-  private log(level: "info" | "error", message: string): void {
+  protected log(level: "info" | "error", message: string): void {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       const fn = level === "error" ? console.error : console.log;
       fn(`[${this.logPrefix}] ${message}`);

package/src/infrastructure/executors/index.ts

@@ -4,4 +4,4 @@
  */
 
 export { BaseExecutor } from "./base-executor";
-export type { BaseExecutorOptions } from "./base-executor";
+export type { BaseExecutorOptions } from "./base-executor.types";

package/src/infrastructure/http/http-fetch-handler.ts

@@ -19,7 +19,7 @@ export async function fetchWithTimeout<T>(
   const { retries = 0 } = options;
 
   const operation = async (): Promise<T> => {
-    const response = await executeRequest<T>(url, options);
+    const response = await executeRequest(url, options);
 
     if (!isSuccessResponse(response)) {
       const errorMessage = await extractErrorMessage(response);

package/src/infrastructure/http/http-request-executor.ts

@@ -11,7 +11,7 @@ import type { RequestOptions } from "./api-client.types";
 /**
  * Executes HTTP request with timeout
  */
-export async function executeRequest<T>(
+export async function executeRequest(
   url: string,
   options: RequestOptions = {}
 ): Promise<Response> {

package/src/infrastructure/utils/domain-guards.ts

@@ -2,7 +2,8 @@
  * Domain-Specific Type Guards
  */
 
-import { hasProperty, isObject } from "./structure-guards";
+import { hasProperty } from "./structure-guards";
+import { isObject } from "./primitive-guards";
 import { isNonEmptyString } from "./primitive-guards";
 
 /**

package/src/infrastructure/utils/index.ts

@@ -6,7 +6,6 @@ export * from "./error-classifier.util";
 export * from "./error-message-extractor.util";
 export * from "./error-handling.util";
 export * from "./validation.util";
-export * from "./type-guards.util";
 export * from "./api-client.util";
 export * from "../../domains/background/infrastructure/utils/polling-interval.util";
 export * from "./progress-calculator.util";
@@ -21,3 +20,8 @@ export * from "./provider-validator.util";
 export * from "./base64.util";
 export * from "./video-result-extractor.util";
 export * from "./id-generator.util";
+
+// Export type guards (avoiding duplicate exports)
+export { hasProperty, hasProperties } from "./structure-guards";
+export { isObject, isNonEmptyString, isArray, isNumber, isFunction } from "./primitive-guards";
+export { isCreationWithOutput, isWizardData } from "./domain-guards";

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

@@ -33,6 +33,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   const [state, setState] = useState<GenerationState<TResult>>(INITIAL_STATE);
   const isGeneratingRef = useRef(false);
   const isMountedRef = useRef(true);
+  const abortControllerRef = useRef<AbortController | null>(null);
 
   const offlineStore = useOfflineStore();
   const { showError, showSuccess } = useAlert();
@@ -40,7 +41,10 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 
   useEffect(() => {
     isMountedRef.current = true;
-    return () => { isMountedRef.current = false; };
+    return () => {
+      isMountedRef.current = false;
+      abortControllerRef.current?.abort();
+    };
   }, []);
 
   const handleLifecycleComplete = useCallback(
@@ -91,6 +95,8 @@ export const useGenerationOrchestrator = <TInput, TResult>(
       if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] generate() called");
       if (isGeneratingRef.current) return;
 
+      // Create new AbortController for this generation
+      abortControllerRef.current = new AbortController();
       isGeneratingRef.current = true;
       setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
 
@@ -100,6 +106,11 @@ export const useGenerationOrchestrator = <TInput, TResult>(
           throw createGenerationError("network", alertMessages.networkError);
         }
 
+        // Check if aborted
+        if (abortControllerRef.current.signal.aborted) {
+          throw new Error("Generation aborted");
+        }
+
         // Pre-validate credits before generation to catch concurrent consumption
         const creditCost = strategy.getCreditCost();
         const hasEnoughCredits = await checkCredits(creditCost);
@@ -111,6 +122,11 @@ export const useGenerationOrchestrator = <TInput, TResult>(
           throw createGenerationError("credits", alertMessages.creditFailed);
         }
 
+        // Check if aborted before moderation
+        if (abortControllerRef.current.signal.aborted) {
+          throw new Error("Generation aborted");
+        }
+
         return await handleModeration({
           input,
           moderation,
@@ -125,6 +141,14 @@ export const useGenerationOrchestrator = <TInput, TResult>(
           handleLifecycleComplete,
         });
       } catch (err) {
+        // Don't show error if aborted
+        if (abortControllerRef.current?.signal.aborted) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] Generation aborted");
+          }
+          return;
+        }
+
         const error = parseError(err);
         if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Error:", error);
         if (isMountedRef.current) setState({ status: "error", isGenerating: false, result: null, error });
@@ -134,12 +158,15 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         throw error;
       } finally {
         isGeneratingRef.current = false;
+        abortControllerRef.current = null;
       }
     },
-    [moderation, alertMessages, strategy, checkCredits, onCreditsExhausted, executeGeneration, showError, onError, handleLifecycleComplete],
+    [offlineStore.isOnline, moderation, alertMessages, strategy, checkCredits, onCreditsExhausted, executeGeneration, showError, onError, handleLifecycleComplete],
   );
 
   const reset = useCallback(() => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
     setState(INITIAL_STATE);
     isGeneratingRef.current = false;
   }, []);

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

@@ -15,6 +15,9 @@ import type {
   DualImageInput,
 } from "./use-image-generation.types";
 
+// Export types
+export type { ImageGenerationConfig, ImageGenerationInput, SingleImageInput, DualImageInput } from "./use-image-generation.types";
+
 const isDualImageInput = (input: ImageGenerationInput): input is DualImageInput =>
   "sourceImageBase64" in input && "targetImageBase64" in input;