@umituz/react-native-ai-generation-content 1.20.1 → 1.20.3

package/package.json

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

package/src/features/hd-touch-up/index.ts

@@ -1,5 +1,4 @@
 /**
-export * from "./presentation/components";
  * HD Touch Up Feature
  * Provider-agnostic HD enhancement feature
  */
@@ -16,12 +15,7 @@ export type {
 } from "./domain";
 
 // Presentation Hooks
-export { useHDTouchUpFeature } from "./presentation";
-export type {
-  UseHDTouchUpFeatureProps,
-  UseHDTouchUpFeatureReturn,
-} from "./presentation";
+export { useHDTouchUpFeature, type UseHDTouchUpFeatureProps } from "./presentation";
 
 // Presentation Components
-export { HDTouchUpFeature } from "./presentation";
-export type { HDTouchUpFeatureProps } from "./presentation";
+export { HDTouchUpFeature, type HDTouchUpFeatureProps } from "./presentation";

package/src/features/hd-touch-up/presentation/hooks/index.ts

@@ -1,5 +1 @@
-export { useHDTouchUpFeature } from "./useHDTouchUpFeature";
-export type {
-  UseHDTouchUpFeatureProps,
-  UseHDTouchUpFeatureReturn,
-} from "./useHDTouchUpFeature";
+export { useHDTouchUpFeature, type UseHDTouchUpFeatureProps } from "./useHDTouchUpFeature";

package/src/features/hd-touch-up/presentation/hooks/useHDTouchUpFeature.ts

@@ -1,15 +1,10 @@
 /**
  * useHDTouchUpFeature Hook
  * Uses base single image hook for HD touch up
- * Uses centralized orchestrator for credit/error handling
  */
 
-import {
-  useSingleImageFeature,
-  type BaseSingleImageHookReturn,
-} from "../../../image-to-image";
-import type { AlertMessages } from "../../../../presentation/hooks/generation";
-import type { HDTouchUpFeatureConfig } from "../../domain/types";
+import { useSingleImageFeature, type BaseSingleImageHookReturn } from "../../../image-to-image";
+import type { HDTouchUpFeatureConfig, HDTouchUpResult } from "../../domain/types";
 
 export interface UseHDTouchUpFeatureProps {
   config: HDTouchUpFeatureConfig;
@@ -18,29 +13,11 @@ export interface UseHDTouchUpFeatureProps {
   onBeforeProcess?: () => Promise<boolean>;
 }
 
-export interface UseHDTouchUpFeatureOptions {
-  /** Alert messages for error handling */
-  alertMessages?: AlertMessages;
-  /** User ID for credit operations */
-  userId?: string;
-  /** Callback when credits are exhausted */
-  onCreditsExhausted?: () => void;
-}
-
-export interface UseHDTouchUpFeatureReturn extends BaseSingleImageHookReturn {}
-
-export function useHDTouchUpFeature(
-  props: UseHDTouchUpFeatureProps,
-  options?: UseHDTouchUpFeatureOptions,
-): UseHDTouchUpFeatureReturn {
+export function useHDTouchUpFeature(props: UseHDTouchUpFeatureProps): BaseSingleImageHookReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
 
-  // Cast config to any to bypass strict type checking while maintaining runtime behavior
-  return useSingleImageFeature(
+  return useSingleImageFeature<HDTouchUpFeatureConfig, HDTouchUpResult>(
     { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
-    {
-      buildInput: (imageBase64) => ({ imageBase64 }),
-      ...options,
-    },
+    { buildInput: (imageBase64) => ({ imageBase64 }) },
   );
 }

package/src/features/image-to-image/domain/types/partials/hook.types.ts

@@ -9,9 +9,7 @@ import type { BaseSingleImageState, BaseDualImageState } from "./state.types";
 /**
  * Base hook props for single image features
  */
-export interface BaseSingleImageHookProps<
-  TConfig extends SingleImageConfig = SingleImageConfig,
-> {
+export interface BaseSingleImageHookProps<TConfig = SingleImageConfig> {
   config: TConfig;
   onSelectImage: () => Promise<string | null>;
   onSaveImage: (imageUrl: string) => Promise<void>;

package/src/features/image-to-image/presentation/hooks/useSingleImageFeature.ts

@@ -19,7 +19,7 @@ import type {
   BaseImageResult,
 } from "../../domain/types";
 
-export interface SingleImageFeatureOptions<TConfig extends SingleImageConfig> {
+export interface SingleImageFeatureOptions<TConfig = SingleImageConfig> {
   buildInput?: (imageBase64: string, config: TConfig) => Record<string, unknown>;
   /** Alert messages for error handling */
   alertMessages?: AlertMessages;
@@ -43,13 +43,16 @@ interface SingleImageInput {
 }
 
 export function useSingleImageFeature<
-  TConfig extends SingleImageConfig = SingleImageConfig,
-  TResult extends BaseImageResult = BaseImageResult,
+  TConfig = SingleImageConfig,
+  TResult = BaseImageResult,
 >(
   props: BaseSingleImageHookProps<TConfig>,
   options?: SingleImageFeatureOptions<TConfig>,
 ): BaseSingleImageHookReturn {
-  const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
+  const { config: rawConfig, onSelectImage, onSaveImage, onBeforeProcess } = props;
+
+  // Cast config to base type for internal usage
+  const config = rawConfig as unknown as SingleImageConfig;
 
   // Image selection state (separate from orchestrator state)
   const [imageUri, setImageUri] = useState<string | null>(null);
@@ -73,7 +76,7 @@ export function useSingleImageFeature<
         // Notify completion with creationId
         const creationId = creationIdRef.current;
         if (creationId) {
-          config.onProcessingComplete?.({ ...result, creationId } as unknown as TResult);
+          config.onProcessingComplete?.({ ...result, creationId } as BaseImageResult);
         }
 
         return result.imageUrl;
@@ -124,14 +127,14 @@ export function useSingleImageFeature<
       const imageBase64 = await config.prepareImage(imageUri);
 
       const input: SingleImageInput = options?.buildInput
-        ? { imageBase64, options: options.buildInput(imageBase64, config) }
+        ? { imageBase64, options: options.buildInput(imageBase64, rawConfig) }
         : { imageBase64 };
 
       await orchestrator.generate(input);
     } catch (error) {
       // Error already handled by orchestrator
     }
-  }, [imageUri, config, options, onBeforeProcess, orchestrator]);
+  }, [imageUri, config, rawConfig, options, onBeforeProcess, orchestrator]);
 
   const save = useCallback(async () => {
     if (!orchestrator.result) return;

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

@@ -6,24 +6,47 @@
 import { useState, useCallback, useMemo } from "react";
 import { useGenerationExecution } from "./useGenerationExecution";
 import { validateImageToVideoGeneration } from "./useImageToVideoValidation";
-import { INITIAL_IMAGE_TO_VIDEO_STATE } from "./useImageToVideoFeature.constants";
-import type {
-  UseImageToVideoFeatureProps,
-  UseImageToVideoFeatureReturn,
-} from "./useImageToVideoFeature.types";
 import type {
   ImageToVideoFeatureState,
-  ImageToVideoGenerateParams,
+  ImageToVideoFeatureConfig,
   ImageToVideoResult,
+  ImageToVideoFeatureCallbacks,
+  ImageToVideoGenerateParams,
 } from "../../domain/types";
 
 declare const __DEV__: boolean;
 
-export function useImageToVideoFeature(
-  props: UseImageToVideoFeatureProps,
-): UseImageToVideoFeatureReturn {
+// Initial state (inlined from constants file)
+const INITIAL_STATE: ImageToVideoFeatureState = {
+  imageUri: null,
+  motionPrompt: "",
+  videoUrl: null,
+  thumbnailUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+// Types (inlined from types file)
+export interface UseImageToVideoFeatureProps {
+  config: ImageToVideoFeatureConfig;
+  callbacks?: ImageToVideoFeatureCallbacks;
+  userId: string;
+}
+
+export interface UseImageToVideoFeatureReturn {
+  state: ImageToVideoFeatureState;
+  setImageUri: (uri: string) => void;
+  setMotionPrompt: (prompt: string) => void;
+  generate: (params?: ImageToVideoGenerateParams) => Promise<ImageToVideoResult>;
+  reset: () => void;
+  isReady: boolean;
+  canGenerate: boolean;
+}
+
+export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseImageToVideoFeatureReturn {
   const { config, callbacks, userId } = props;
-  const [state, setState] = useState<ImageToVideoFeatureState>(INITIAL_IMAGE_TO_VIDEO_STATE);
+  const [state, setState] = useState<ImageToVideoFeatureState>(INITIAL_STATE);
 
   const executeGeneration = useGenerationExecution({
     userId,
@@ -68,30 +91,17 @@ export function useImageToVideoFeature(
         return validation;
       }
 
-      return executeGeneration(
-        effectiveImageUri!,
-        effectiveMotionPrompt,
-        options
-      );
+      return executeGeneration(effectiveImageUri!, effectiveMotionPrompt, options);
     },
     [state.imageUri, state.motionPrompt, callbacks, config.creditCost, executeGeneration],
   );
 
   const reset = useCallback(() => {
-    setState(INITIAL_IMAGE_TO_VIDEO_STATE);
+    setState(INITIAL_STATE);
   }, []);
 
-  const isReady = useMemo(
-    () => state.imageUri !== null && !state.isProcessing,
-    [state.imageUri, state.isProcessing],
-  );
-
-  const canGenerate = useMemo(
-    () => isReady && !state.error,
-    [isReady, state.error],
-  );
+  const isReady = useMemo(() => state.imageUri !== null && !state.isProcessing, [state.imageUri, state.isProcessing]);
+  const canGenerate = useMemo(() => isReady && !state.error, [isReady, state.error]);
 
   return { state, setImageUri, setMotionPrompt, generate, reset, isReady, canGenerate };
 }
-
-export type { UseImageToVideoFeatureProps, UseImageToVideoFeatureReturn } from "./useImageToVideoFeature.types";

package/src/features/photo-restoration/index.ts

@@ -1,5 +1,4 @@
 /**
-export * from "./presentation/components";
  * Photo Restoration Feature
  * Provider-agnostic photo restoration feature
  */
@@ -16,15 +15,8 @@ export type {
 } from "./domain";
 
 // Presentation Hooks
-export { usePhotoRestoreFeature } from "./presentation";
-export type {
-  UsePhotoRestoreFeatureProps,
-  UsePhotoRestoreFeatureReturn,
-} from "./presentation";
+export { usePhotoRestoreFeature, type UsePhotoRestoreFeatureProps } from "./presentation";
 
 // Presentation Components
 export { PhotoRestoreFeature, PhotoRestoreResultView } from "./presentation";
-export type {
-  PhotoRestoreFeatureProps,
-  PhotoRestoreResultViewProps,
-} from "./presentation";
+export type { PhotoRestoreFeatureProps, PhotoRestoreResultViewProps } from "./presentation";

package/src/features/photo-restoration/presentation/hooks/index.ts

@@ -1,5 +1 @@
-export { usePhotoRestoreFeature } from "./usePhotoRestoreFeature";
-export type {
-  UsePhotoRestoreFeatureProps,
-  UsePhotoRestoreFeatureReturn,
-} from "./usePhotoRestoreFeature";
+export { usePhotoRestoreFeature, type UsePhotoRestoreFeatureProps } from "./usePhotoRestoreFeature";

package/src/features/photo-restoration/presentation/hooks/usePhotoRestoreFeature.ts

@@ -1,15 +1,10 @@
 /**
  * usePhotoRestoreFeature Hook
  * Uses base single image hook for photo restoration
- * Uses centralized orchestrator for credit/error handling
  */
 
-import {
-  useSingleImageFeature,
-  type BaseSingleImageHookReturn,
-} from "../../../image-to-image";
-import type { AlertMessages } from "../../../../presentation/hooks/generation";
-import type { PhotoRestoreFeatureConfig } from "../../domain/types";
+import { useSingleImageFeature, type BaseSingleImageHookReturn } from "../../../image-to-image";
+import type { PhotoRestoreFeatureConfig, PhotoRestoreResult } from "../../domain/types";
 
 export interface UsePhotoRestoreFeatureProps {
   config: PhotoRestoreFeatureConfig;
@@ -18,29 +13,11 @@ export interface UsePhotoRestoreFeatureProps {
   onBeforeProcess?: () => Promise<boolean>;
 }
 
-export interface UsePhotoRestoreFeatureOptions {
-  /** Alert messages for error handling */
-  alertMessages?: AlertMessages;
-  /** User ID for credit operations */
-  userId?: string;
-  /** Callback when credits are exhausted */
-  onCreditsExhausted?: () => void;
-}
-
-export interface UsePhotoRestoreFeatureReturn extends BaseSingleImageHookReturn {}
-
-export function usePhotoRestoreFeature(
-  props: UsePhotoRestoreFeatureProps,
-  options?: UsePhotoRestoreFeatureOptions,
-): UsePhotoRestoreFeatureReturn {
+export function usePhotoRestoreFeature(props: UsePhotoRestoreFeatureProps): BaseSingleImageHookReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
 
-  // Cast config to any to bypass strict type checking while maintaining runtime behavior
-  return useSingleImageFeature(
+  return useSingleImageFeature<PhotoRestoreFeatureConfig, PhotoRestoreResult>(
     { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
-    {
-      buildInput: (imageBase64) => ({ imageBase64 }),
-      ...options,
-    },
+    { buildInput: (imageBase64) => ({ imageBase64 }) },
   );
 }

package/src/features/remove-background/presentation/hooks/index.ts

@@ -1,6 +1 @@
-/**
- * Remove Background Presentation Hooks Index
- */
-
-export { useRemoveBackgroundFeature } from "./useRemoveBackgroundFeature";
-export type { UseRemoveBackgroundFeatureProps } from "./useRemoveBackgroundFeature";
+export { useRemoveBackgroundFeature, type UseRemoveBackgroundFeatureProps } from "./useRemoveBackgroundFeature";

package/src/features/remove-background/presentation/hooks/useRemoveBackgroundFeature.ts

@@ -3,14 +3,8 @@
  * Uses base single image hook for background removal
  */
 
-import {
-  useSingleImageFeature,
-  type BaseSingleImageHookReturn,
-} from "../../../image-to-image";
-import type {
-  RemoveBackgroundFeatureConfig,
-  RemoveBackgroundResult,
-} from "../../domain/types";
+import { useSingleImageFeature, type BaseSingleImageHookReturn } from "../../../image-to-image";
+import type { RemoveBackgroundFeatureConfig, RemoveBackgroundResult } from "../../domain/types";
 
 export interface UseRemoveBackgroundFeatureProps {
   config: RemoveBackgroundFeatureConfig;
@@ -19,13 +13,11 @@ export interface UseRemoveBackgroundFeatureProps {
   onBeforeProcess?: () => Promise<boolean>;
 }
 
-export function useRemoveBackgroundFeature(
-  props: UseRemoveBackgroundFeatureProps,
-): BaseSingleImageHookReturn {
+export function useRemoveBackgroundFeature(props: UseRemoveBackgroundFeatureProps): BaseSingleImageHookReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
 
   return useSingleImageFeature<RemoveBackgroundFeatureConfig, RemoveBackgroundResult>(
-    { config, onSelectImage, onSaveImage, onBeforeProcess },
+    { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
     {
       buildInput: (imageBase64, cfg) => ({
         imageBase64,

package/src/features/text-to-video/presentation/hooks/useTextToVideoFeature.ts

@@ -1,9 +1,15 @@
 /**
  * useTextToVideoFeature Hook
- * Single Responsibility: Orchestrate text-to-video generation with callbacks
+ * Uses centralized orchestrator for auth, credits, moderation, and error handling
  */
 
 import { useState, useCallback, useMemo } from "react";
+import {
+  useGenerationOrchestrator,
+  type GenerationStrategy,
+  type AlertMessages,
+} from "../../../../presentation/hooks/generation";
+import { executeTextToVideo } from "../../infrastructure/services";
 import type {
   TextToVideoFeatureState,
   TextToVideoConfig,
@@ -13,7 +19,6 @@ import type {
   TextToVideoInputBuilder,
   TextToVideoResultExtractor,
 } from "../../domain/types";
-import { executeVideoGeneration } from "./textToVideoExecution";
 
 declare const __DEV__: boolean;
 
@@ -47,12 +52,126 @@ const INITIAL_STATE: TextToVideoFeatureState = {
   error: null,
 };
 
-export function useTextToVideoFeature(
-  props: UseTextToVideoFeatureProps,
-): UseTextToVideoFeatureReturn {
+const DEFAULT_ALERT_MESSAGES: AlertMessages = {
+  networkError: "No internet connection. Please check your network.",
+  policyViolation: "Content not allowed. Please try again.",
+  saveFailed: "Failed to save. Please try again.",
+  creditFailed: "Credit operation failed. Please try again.",
+  unknown: "An error occurred. Please try again.",
+};
+
+interface VideoGenerationInput {
+  prompt: string;
+  options?: TextToVideoOptions;
+  creationId: string;
+}
+
+function generateCreationId(): string {
+  return `text-to-video_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function useTextToVideoFeature(props: UseTextToVideoFeatureProps): UseTextToVideoFeatureReturn {
   const { config, callbacks, userId, buildInput, extractResult } = props;
   const [state, setState] = useState<TextToVideoFeatureState>(INITIAL_STATE);
 
+  // Strategy for orchestrator
+  const strategy: GenerationStrategy<VideoGenerationInput, TextToVideoResult> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[TextToVideo] Executing generation:", input.prompt.slice(0, 100));
+        }
+
+        // Notify generation start
+        callbacks.onGenerationStart?.({
+          creationId: input.creationId,
+          type: "text-to-video",
+          prompt: input.prompt,
+          metadata: input.options as Record<string, unknown> | undefined,
+        }).catch(() => {});
+
+        const result = await executeTextToVideo(
+          { prompt: input.prompt, userId, options: input.options },
+          {
+            model: config.model,
+            buildInput,
+            extractResult,
+            onProgress: (progress) => {
+              setState((prev) => ({ ...prev, progress }));
+              onProgress?.(progress);
+              callbacks.onProgress?.(progress);
+            },
+          },
+        );
+
+        if (!result.success || !result.videoUrl) {
+          throw new Error(result.error || "Generation failed");
+        }
+
+        // Update state with result
+        setState((prev) => ({
+          ...prev,
+          videoUrl: result.videoUrl ?? null,
+          thumbnailUrl: result.thumbnailUrl ?? null,
+        }));
+
+        return result;
+      },
+      getCreditCost: () => config.creditCost,
+      save: async (result, uid) => {
+        if (result.success && result.videoUrl) {
+          await callbacks.onCreationSave?.({
+            creationId: generateCreationId(),
+            type: "text-to-video",
+            videoUrl: result.videoUrl,
+            thumbnailUrl: result.thumbnailUrl,
+            prompt: state.prompt,
+          });
+        }
+      },
+    }),
+    [config, callbacks, buildInput, extractResult, userId, state.prompt],
+  );
+
+  // Use orchestrator with optional callbacks for credits
+  const orchestrator = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages: DEFAULT_ALERT_MESSAGES,
+    auth: callbacks.onAuthCheck
+      ? { isAuthenticated: callbacks.onAuthCheck, onAuthRequired: () => {} }
+      : undefined,
+    credits: callbacks.onCreditCheck
+      ? {
+          checkCredits: async (cost) => (await callbacks.onCreditCheck?.(cost)) ?? true,
+          deductCredits: async (cost) => { await callbacks.onCreditDeduct?.(cost); },
+          onCreditsExhausted: () => callbacks.onShowPaywall?.(config.creditCost),
+        }
+      : undefined,
+    moderation: callbacks.onModeration
+      ? {
+          checkContent: async (input) => {
+            const result = await callbacks.onModeration!((input as VideoGenerationInput).prompt);
+            return result;
+          },
+          onShowWarning: callbacks.onShowModerationWarning,
+        }
+      : undefined,
+    onSuccess: (result) => {
+      const videoResult = result as TextToVideoResult;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToVideo] Success!", videoResult.videoUrl?.slice(0, 50));
+      }
+      callbacks.onGenerate?.(videoResult);
+    },
+    onError: (err) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToVideo] Error:", err.message);
+      }
+      setState((prev) => ({ ...prev, error: err.message }));
+      callbacks.onError?.(err.message);
+    },
+  });
+
   const setPrompt = useCallback(
     (prompt: string) => {
       setState((prev) => ({ ...prev, prompt, error: null }));
@@ -70,9 +189,6 @@ export function useTextToVideoFeature(
         const error = "Prompt is required";
         setState((prev) => ({ ...prev, error }));
         callbacks.onError?.(error);
-        if (__DEV__) {
-          console.log("[TextToVideoFeature] Generate failed: Prompt is required");
-        }
         return { success: false, error };
       }
 
@@ -80,74 +196,30 @@ export function useTextToVideoFeature(
         setState((prev) => ({ ...prev, prompt: effectivePrompt }));
       }
 
-      if (callbacks.onAuthCheck && !callbacks.onAuthCheck()) {
-        if (__DEV__) {
-          console.log("[TextToVideoFeature] Generate failed: Authentication required");
-        }
-        return { success: false, error: "Authentication required" };
-      }
+      setState((prev) => ({ ...prev, isProcessing: true, progress: 0, error: null }));
 
-      if (
-        callbacks.onCreditCheck &&
-        !(await callbacks.onCreditCheck(config.creditCost))
-      ) {
-        callbacks.onShowPaywall?.(config.creditCost);
-        if (__DEV__) {
-          console.log("[TextToVideoFeature] Generate failed: Insufficient credits");
-        }
-        return { success: false, error: "Insufficient credits" };
-      }
+      const creationId = generateCreationId();
+      await orchestrator.generate({ prompt: effectivePrompt, options, creationId });
 
-      if (callbacks.onModeration) {
-        const moderationResult = await callbacks.onModeration(effectivePrompt);
-        if (!moderationResult.allowed && moderationResult.warnings.length > 0) {
-          return new Promise((resolve) => {
-            callbacks.onShowModerationWarning?.(
-              moderationResult.warnings,
-              () => {
-                setState((prev) => ({ ...prev, isProcessing: false }));
-                resolve({ success: false, error: "Content policy violation" });
-              },
-              async () => {
-                const result = await executeVideoGeneration(
-                  effectivePrompt,
-                  options,
-                  { userId, config, callbacks, buildInput, extractResult },
-                  {
-                    onStateUpdate: (update) =>
-                      setState((prev) => ({ ...prev, ...update })),
-                  },
-                );
-                resolve(result);
-              },
-            );
-          });
-        }
+      setState((prev) => ({ ...prev, isProcessing: false }));
+
+      // Return result based on state
+      if (orchestrator.error) {
+        return { success: false, error: orchestrator.error.message };
       }
 
-      return executeVideoGeneration(
-        effectivePrompt,
-        options,
-        { userId, config, callbacks, buildInput, extractResult },
-        { onStateUpdate: (update) => setState((prev) => ({ ...prev, ...update })) },
-      );
+      return orchestrator.result || { success: false, error: "No result" };
     },
-    [state.prompt, callbacks, config, userId, buildInput, extractResult],
+    [state.prompt, callbacks, orchestrator],
   );
 
   const reset = useCallback(() => {
     setState(INITIAL_STATE);
-  }, []);
-
-  const isReady = useMemo(
-    () => state.prompt.trim().length > 0 && !state.isProcessing,
-    [state.prompt, state.isProcessing],
-  );
+    orchestrator.reset();
+  }, [orchestrator]);
 
-  const canGenerate = useMemo(
-    () => isReady && !state.error,
-    [isReady, state.error],
-  );
+  const isReady = useMemo(() => state.prompt.trim().length > 0 && !state.isProcessing, [state.prompt, state.isProcessing]);
+  const canGenerate = useMemo(() => isReady && !state.error, [isReady, state.error]);
 
   return { state, setPrompt, generate, reset, isReady, canGenerate };
 }

package/src/features/upscaling/presentation/hooks/index.ts

@@ -1,2 +1 @@
-export { useUpscaleFeature } from "./useUpscaleFeature";
-export type { UseUpscaleFeatureProps } from "./useUpscaleFeature";
+export { useUpscaleFeature, type UseUpscaleFeatureProps } from "./useUpscaleFeature";

package/src/features/upscaling/presentation/hooks/useUpscaleFeature.ts

@@ -1,12 +1,9 @@
 /**
  * useUpscaleFeature Hook
- * Uses base single image hook with upscale-specific options
+ * Uses base single image hook for image upscaling
  */
 
-import {
-  useSingleImageFeature,
-  type BaseSingleImageHookReturn,
-} from "../../../image-to-image";
+import { useSingleImageFeature, type BaseSingleImageHookReturn } from "../../../image-to-image";
 import type { UpscaleFeatureConfig, UpscaleResult } from "../../domain/types";
 
 export interface UseUpscaleFeatureProps {
@@ -16,13 +13,11 @@ export interface UseUpscaleFeatureProps {
   onBeforeProcess?: () => Promise<boolean>;
 }
 
-export function useUpscaleFeature(
-  props: UseUpscaleFeatureProps,
-): BaseSingleImageHookReturn {
+export function useUpscaleFeature(props: UseUpscaleFeatureProps): BaseSingleImageHookReturn {
   const { config, onSelectImage, onSaveImage, onBeforeProcess } = props;
 
   return useSingleImageFeature<UpscaleFeatureConfig, UpscaleResult>(
-    { config, onSelectImage, onSaveImage, onBeforeProcess },
+    { config: config as never, onSelectImage, onSaveImage, onBeforeProcess },
     {
       buildInput: (imageBase64, cfg) => ({
         imageBase64,

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

@@ -1,15 +0,0 @@
-/**
- * useImageToVideoFeature Constants
- */
-
-import type { ImageToVideoFeatureState } from "../../domain/types";
-
-export const INITIAL_IMAGE_TO_VIDEO_STATE: ImageToVideoFeatureState = {
-  imageUri: null,
-  motionPrompt: "",
-  videoUrl: null,
-  thumbnailUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};

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

@@ -1,27 +0,0 @@
-/**
- * useImageToVideoFeature Type Definitions
- */
-
-import type {
-  ImageToVideoFeatureState,
-  ImageToVideoFeatureConfig,
-  ImageToVideoResult,
-  ImageToVideoFeatureCallbacks,
-  ImageToVideoGenerateParams,
-} from "../../domain/types";
-
-export interface UseImageToVideoFeatureProps {
-  config: ImageToVideoFeatureConfig;
-  callbacks?: ImageToVideoFeatureCallbacks;
-  userId: string;
-}
-
-export interface UseImageToVideoFeatureReturn {
-  state: ImageToVideoFeatureState;
-  setImageUri: (uri: string) => void;
-  setMotionPrompt: (prompt: string) => void;
-  generate: (params?: ImageToVideoGenerateParams) => Promise<ImageToVideoResult>;
-  reset: () => void;
-  isReady: boolean;
-  canGenerate: boolean;
-}

package/src/features/text-to-video/presentation/hooks/textToVideoExecution.ts

@@ -1,134 +0,0 @@
-/**
- * Text-to-Video Execution
- * Core execution logic for text-to-video generation
- */
-
-import { executeTextToVideo } from "../../infrastructure/services";
-import type {
-  TextToVideoConfig,
-  TextToVideoCallbacks,
-  TextToVideoResult,
-  TextToVideoOptions,
-  TextToVideoInputBuilder,
-  TextToVideoResultExtractor,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface ExecutionContext {
-  userId: string;
-  config: TextToVideoConfig;
-  callbacks: TextToVideoCallbacks;
-  buildInput: TextToVideoInputBuilder;
-  extractResult?: TextToVideoResultExtractor;
-}
-
-export interface ExecutionCallbacks {
-  onStateUpdate: (update: {
-    isProcessing?: boolean;
-    progress?: number;
-    videoUrl?: string | null;
-    thumbnailUrl?: string | null;
-    error?: string | null;
-  }) => void;
-}
-
-function generateCreationId(): string {
-  return `text-to-video_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
-export async function executeVideoGeneration(
-  prompt: string,
-  options: TextToVideoOptions | undefined,
-  context: ExecutionContext,
-  executionCallbacks: ExecutionCallbacks,
-): Promise<TextToVideoResult> {
-  const { userId, config, callbacks, buildInput, extractResult } = context;
-  const { onStateUpdate } = executionCallbacks;
-  const creationId = generateCreationId();
-
-  onStateUpdate({ isProcessing: true, progress: 0, error: null });
-
-  if (__DEV__) {
-    console.log(
-      "[TextToVideoFeature] Starting generation with prompt:",
-      prompt,
-      "creationId:",
-      creationId,
-    );
-  }
-
-  if (callbacks.onGenerationStart) {
-    callbacks
-      .onGenerationStart({
-        creationId,
-        type: "text-to-video",
-        prompt,
-        metadata: options as Record<string, unknown> | undefined,
-      })
-      .catch((err) => {
-        if (__DEV__) {
-          console.warn("[TextToVideoFeature] onGenerationStart failed:", err);
-        }
-      });
-  }
-
-  if (__DEV__) {
-    console.log("[TextToVideoFeature] Starting executeTextToVideo...");
-  }
-
-  try {
-    const result = await executeTextToVideo(
-      { prompt, userId, options },
-      {
-        model: config.model,
-        buildInput,
-        extractResult,
-        onProgress: (progress) => {
-          onStateUpdate({ progress });
-          callbacks.onProgress?.(progress);
-        },
-      },
-    );
-
-    if (result.success && result.videoUrl) {
-      onStateUpdate({
-        videoUrl: result.videoUrl,
-        thumbnailUrl: result.thumbnailUrl ?? null,
-        isProcessing: false,
-        progress: 100,
-      });
-
-      if (callbacks.onCreditDeduct) {
-        await callbacks.onCreditDeduct(config.creditCost);
-      }
-
-      if (callbacks.onCreationSave) {
-        await callbacks.onCreationSave({
-          creationId,
-          type: "text-to-video",
-          videoUrl: result.videoUrl,
-          thumbnailUrl: result.thumbnailUrl,
-          prompt,
-          metadata: options as Record<string, unknown> | undefined,
-        });
-      }
-
-      callbacks.onGenerate?.(result);
-    } else {
-      const error = result.error || "Generation failed";
-      onStateUpdate({ isProcessing: false, error });
-      callbacks.onError?.(error);
-    }
-
-    return result;
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    if (__DEV__) {
-      console.error("[TextToVideoFeature] Generation error:", errorMessage);
-    }
-    onStateUpdate({ isProcessing: false, error: errorMessage });
-    callbacks.onError?.(errorMessage);
-    return { success: false, error: errorMessage };
-  }
-}