@umituz/react-native-ai-generation-content 1.90.5 → 1.90.7

package/package.json

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

package/src/domains/access-control/hooks/useAIFeatureGate.ts

@@ -15,7 +15,6 @@ import { useCallback, useMemo } from "react";
 import { useOffline } from "@umituz/react-native-design-system/offline";
 import { useAuth, useAuthModalStore } from "@umituz/react-native-auth";
 import {
-  usePremiumStatus,
   useCredits,
   usePaywallVisibility,
   useFeatureGate,
@@ -47,11 +46,12 @@ export function useAIFeatureGate(options: AIFeatureGateOptions): AIFeatureGateRe
   const { isOffline } = useOffline();
   const { hasFirebaseUser } = useAuth();
   const { showAuthModal } = useAuthModalStore();
-  const { isPremium } = usePremiumStatus();
   const { credits, isCreditsLoaded, isLoading: isCreditsLoading } = useCredits();
   const { openPaywall } = usePaywallVisibility();
   const creditBalance = credits?.credits ?? 0;
   const hasCredits = creditBalance >= creditCost;
+  // TODO: Replace with actual premium status check from subscription package
+  const isPremium = false;
 
   const { requireFeature: requireFeatureFromPackage } = useFeatureGate({
     isAuthenticated: hasFirebaseUser,

package/src/domains/creations/domain/constants/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Creation Domain Constants
+ * Centralized constants for creation field names, status, and validation
+ */
+
+export {
+  CREATION_FIELDS,
+  UPDATABLE_FIELDS,
+} from './creation-fields.constants';
+
+// Re-export CreationFieldName as a type alias
+import type { CreationFieldName } from './creation-fields.constants';
+export type { CreationFieldName };
+
+export {
+  CREATION_STATUS,
+} from './creation-status.constants';
+
+export {
+  CREATION_VALIDATION,
+} from './creation-validation.constants';

package/src/domains/creations/domain/utils/creation-format.util.ts

@@ -1,6 +1,6 @@
 /**
  * Creation Format Utilities
- * Single Responsibility: Text formatting
+ * Single Responsibility: Text formatting and ID generation
  */
 
 /**
@@ -10,3 +10,10 @@ export function truncateText(text: string, maxLength: number): string {
   if (text.length <= maxLength) return text;
   return text.substring(0, maxLength - 3) + "...";
 }
+
+/**
+ * Generate unique creation ID
+ */
+export function generateCreationId(): string {
+  return `creation_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}

package/src/domains/creations/domain/utils/index.ts

@@ -5,11 +5,15 @@
 
 // Display utilities
 export {
-  truncateText,
+  getTypeIcon,
+  getTypeTextKey,
+  getTypeText,
+  getCreationTitle,
 } from './creation-display.util';
 
 // Format utilities
 export {
+  truncateText,
   generateCreationId,
 } from './creation-format.util';
 

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-preparation.ts

@@ -4,7 +4,7 @@
  * Handles photo URI extraction and appearance analysis
  */
 
-import { getAppearanceContext } from "../../appearance-analysis";
+import { getAppearanceContext } from "../appearance-analysis";
 import { logBuilderStep } from "./utils";
 import type { CoupleGenerationInputParams } from "./types";
 

package/src/domains/generation/infrastructure/couple-generation-builder/builder-scenario.ts

@@ -9,7 +9,7 @@ import {
   refinePromptForCouple,
   prependContext,
 } from "../../../../infrastructure/utils/couple-input.util";
-import { getAppearanceContext } from "../../appearance-analysis";
+import { getAppearanceContext } from "../appearance-analysis";
 import type {
   ScenarioGenerationInputParams,
   CoupleGenerationInput,

package/src/domains/generation/presentation/useAIGeneration.hook.ts

@@ -82,8 +82,8 @@ export function useAIGeneration(
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages: alertMessages || DEFAULT_ALERT_MESSAGES,
-    onSuccess,
-    onError: onError ? (error) => onError(error.message) : undefined,
+    onSuccess: async (result) => onSuccess?.(result),
+    onError: onError ? async (error) => onError(error.message) : undefined,
   });
 
   return {

package/src/domains/generation/wizard/presentation/hooks/photo-upload/types.ts

@@ -2,7 +2,10 @@
  * Generic Photo Upload State Hook - Type Definitions
  */
 
-import type { UploadedImage } from "../../../../../../../presentation/hooks/generation/useAIGenerateState";
+import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
+
+// Re-export for use in this module
+export type { UploadedImage };
 
 export interface PhotoUploadConfig {
   readonly maxFileSizeMB?: number;

package/src/domains/generation/wizard/presentation/hooks/photo-upload/usePhotoUploadStateLogic.ts

@@ -4,7 +4,7 @@
 
 import { useCallback, useRef, useEffect } from "react";
 import { useMedia, MediaQuality, MediaValidationError, MEDIA_CONSTANTS } from "@umituz/react-native-design-system/media";
-import type { UploadedImage } from "../../../../presentation/hooks/generation/useAIGenerateState";
+import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
 import type { PhotoUploadConfig, PhotoUploadError, PhotoUploadTranslations } from "./types";
 
 export function usePhotoUploadStateLogic(

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationCallbacks.ts

@@ -3,7 +3,7 @@
  */
 
 import { useCallback } from "react";
-import type { GenerationUrls } from "../../generation-result.utils";
+import type { GenerationUrls } from "../generation-result.utils";
 import type {
   UseVideoQueueGenerationProps,
 } from "../use-video-queue-generation.types";

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationPolling.ts

@@ -56,7 +56,7 @@ export function usePollStatus(
  * Hook to sync callback refs
  */
 export function useCallbackRefs(
-  handleComplete: (urls: import("../../generation-result.utils").GenerationUrls) => Promise<void>,
+  handleComplete: (urls: import("../generation-result.utils").GenerationUrls) => Promise<void>,
   handleError: (errorMsg: string) => Promise<void>,
   pollStatus: () => Promise<void>,
   refs: VideoQueueRefs,

package/src/domains/image-to-video/domain/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Image-to-Video Domain Types
+ * Exports all domain types and constants
+ */
+
+export * from './types';

package/src/domains/image-to-video/presentation/components/index.ts

@@ -18,5 +18,5 @@ export type {
 } from "./ImageSelectionGrid";
 
 // Action Components
-export { GenerateButton as ImageToVideoGenerateButton } from "../../../../presentation/components/buttons/GenerateButton";
-export type { GenerateButtonProps as ImageToVideoGenerateButtonProps } from "../../../../presentation/components/buttons/GenerateButton";
+export { GenerateButton as ImageToVideoGenerateButton } from "../../../../../presentation/components/buttons/GenerateButton";
+export type { GenerateButtonProps as ImageToVideoGenerateButtonProps } from "../../../../../presentation/components/buttons/GenerateButton";

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

@@ -17,6 +17,7 @@ export const INITIAL_STATE: ImageToVideoFeatureState = {
   motionPrompt: "",
   videoUrl: null,
   thumbnailUrl: null,
+  output: null,
   isProcessing: false,
   progress: 0,
   error: null,

package/src/domains/image-to-video/presentation/index.ts

@@ -0,0 +1,55 @@
+/**
+ * Image-to-Video Presentation Index
+ * Exports all presentation layer items (hooks and components)
+ */
+
+// =============================================================================
+// HOOKS
+// =============================================================================
+
+// Form State Hook
+export { useImageToVideoFormState } from "./hooks";
+export type {
+  UseImageToVideoFormStateOptions,
+  UseImageToVideoFormStateReturn,
+} from "./hooks";
+
+// Generation Hook
+export { useImageToVideoGeneration } from "./hooks";
+export type {
+  UseImageToVideoGenerationOptions,
+  UseImageToVideoGenerationReturn,
+} from "./hooks";
+
+// Combined Form Hook
+export { useImageToVideoForm } from "./hooks";
+export type {
+  UseImageToVideoFormOptions,
+  UseImageToVideoFormReturn,
+} from "./hooks";
+
+// Provider-based Feature Hook
+export { useImageToVideoFeature } from "./hooks";
+export type {
+  UseImageToVideoFeatureProps,
+  UseImageToVideoFeatureReturn,
+} from "./hooks";
+
+// =============================================================================
+// COMPONENTS
+// =============================================================================
+
+export {
+  ImageToVideoAnimationStyleSelector,
+  ImageToVideoDurationSelector,
+  ImageToVideoSelectionGrid,
+  ImageToVideoGenerateButton,
+} from "./components";
+
+export type {
+  ImageToVideoAnimationStyleSelectorProps,
+  ImageToVideoDurationSelectorProps,
+  ImageToVideoSelectionGridProps,
+  ImageToVideoSelectionGridTranslations,
+  ImageToVideoGenerateButtonProps,
+} from "./components";

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

@@ -60,9 +60,11 @@ class TextToImageExecutor extends BaseExecutor<
 
   protected transformResult(
     extracted: ExtractedImageResult,
+    request: TextToImageRequest,
   ): TextToImageResult {
     return {
       success: true,
+      requestId: request.meta.requestId,
       imageUrl: extracted.imageUrl,
       imageUrls: extracted.imageUrls,
     };
@@ -100,7 +102,11 @@ export async function executeTextToImage(
   if (isSuccess(result)) {
     return result.value;
   }
-  return { success: false, error: result.error };
+  return {
+    success: false,
+    error: result.error,
+    requestId: request.meta.requestId,
+  };
 }
 
 /**

package/src/domains/text-to-video/domain/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Text-to-Video Domain Types
+ * Exports all domain types and constants
+ */
+
+export * from './types';

package/src/domains/text-to-video/domain/types/state.types.ts

@@ -38,6 +38,23 @@ export interface FrameData {
   order: number;
 }
 
+/**
+ * Text-to-video generation state
+ * Tracks the progress of video generation
+ */
+export interface TextToVideoGenerationState {
+  isGenerating: boolean;
+  error: string | null;
+}
+
+/**
+ * Initial generation state
+ */
+export const INITIAL_GENERATION_STATE: TextToVideoGenerationState = {
+  isGenerating: false,
+  error: null,
+};
+
 /**
  * Initial form state
  */

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

@@ -82,9 +82,11 @@ class TextToVideoExecutor extends BaseExecutor<
 
   protected transformResult(
     extracted: ExtractedVideoResult,
+    request: TextToVideoRequest,
   ): TextToVideoResult {
     return {
       success: true,
+      requestId: request.meta.requestId,
       videoUrl: extracted.videoUrl,
       thumbnailUrl: extracted.thumbnailUrl,
     };
@@ -122,7 +124,11 @@ export async function executeTextToVideo(
   if (isSuccess(result)) {
     return result.value;
   }
-  return { success: false, error: result.error };
+  return {
+    success: false,
+    error: result.error,
+    requestId: request.meta.requestId,
+  };
 }
 
 /**

package/src/domains/text-to-video/presentation/hooks/index.ts

@@ -14,4 +14,4 @@ export { useTextToVideoForm } from "./useTextToVideoForm";
 export type {
   UseTextToVideoFormProps,
   UseTextToVideoFormReturn,
-} from "./useTextToVideoForm";
+} from "./useTextToVideoForm.types";

package/src/domains/text-to-video/presentation/hooks/textToVideoStrategy.ts

@@ -5,10 +5,12 @@ import type {
   TextToVideoConfig,
   TextToVideoCallbacks,
   TextToVideoResult,
+  TextToVideoRequest,
   TextToVideoOptions,
   TextToVideoInputBuilder,
   TextToVideoResultExtractor,
 } from "../../domain/types";
+import type { BaseRequestMeta } from "../../../../shared-kernel/base-types";
 
 interface VideoGenerationInput {
   prompt: string;
@@ -36,6 +38,19 @@ export const createTextToVideoStrategy = (
     execute: async (input) => {
       creationIdRef.current = input.creationId;
 
+      const meta: BaseRequestMeta = {
+        requestId: input.creationId,
+        userId,
+        timestamp: Date.now(),
+        priority: "normal",
+      };
+
+      const request: TextToVideoRequest = {
+        prompt: input.prompt,
+        options: input.options,
+        meta,
+      };
+
       callbacks.onGenerationStart?.({
         creationId: input.creationId,
         type: "text-to-video",
@@ -48,7 +63,7 @@ export const createTextToVideoStrategy = (
       });
 
       const result = await executeTextToVideo(
-        { prompt: input.prompt, userId, options: input.options },
+        request,
         { model: config.model, buildInput, extractResult },
       );
 
@@ -60,6 +75,7 @@ export const createTextToVideoStrategy = (
 
       return {
         success: true,
+        requestId: result.requestId,
         videoUrl: result.videoUrl,
         thumbnailUrl: result.thumbnailUrl,
       };

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

@@ -38,6 +38,7 @@ const INITIAL_STATE: TextToVideoFeatureState = {
   prompt: "",
   videoUrl: null,
   thumbnailUrl: null,
+  output: null,
   isProcessing: false,
   progress: 0,
   error: null,
@@ -84,23 +85,29 @@ export function useTextToVideoFeature(props: UseTextToVideoFeatureProps): UseTex
       if (!prompt.trim()) {
         const error = "Prompt is required";
         setState((prev) => ({ ...prev, error }));
-        return { success: false, error };
+        return { success: false, error, requestId: generateCreationId("text-to-video") };
       }
 
       setState((prev) => ({ ...prev, isProcessing: true, error: null, progress: 0 }));
+      const requestId = generateCreationId("text-to-video");
 
       try {
         const result = await orchestrator.generate({
           prompt: prompt.trim(),
           options: params,
-          creationId: generateCreationId("text-to-video"),
+          creationId: requestId,
         });
         setState((prev) => ({ ...prev, isProcessing: false }));
-        return { success: true, videoUrl: (result as TextToVideoResult)?.videoUrl };
+        return {
+          success: true,
+          requestId,
+          videoUrl: (result as TextToVideoResult)?.videoUrl || null,
+          thumbnailUrl: (result as TextToVideoResult)?.thumbnailUrl || null,
+        };
       } catch (error) {
         const message = error instanceof Error ? error.message : "Generation failed";
         setState((prev) => ({ ...prev, isProcessing: false, error: message }));
-        return { success: false, error: message };
+        return { success: false, error: message, requestId };
       }
     },
     [state.prompt, orchestrator],

package/src/domains/text-to-video/presentation/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Text-to-Video Presentation Index
+ * Exports all presentation layer items (hooks and components)
+ */
+
+// =============================================================================
+// HOOKS
+// =============================================================================
+
+export { useTextToVideoFeature } from "./hooks";
+export type {
+  UseTextToVideoFeatureProps,
+  UseTextToVideoFeatureReturn,
+  TextToVideoGenerateParams,
+} from "./hooks";
+
+export { useTextToVideoForm } from "./hooks";
+export type {
+  UseTextToVideoFormProps,
+  UseTextToVideoFormReturn,
+} from "./hooks";
+
+// =============================================================================
+// COMPONENTS
+// =============================================================================
+
+export {
+  GenerationTabs,
+  FrameSelector,
+  OptionsPanel,
+  HeroSection,
+  HintCarousel,
+} from "./components";

package/src/infrastructure/config/app-services.config.ts

@@ -3,7 +3,7 @@
  * Singleton for storing app-provided service implementations
  */
 
-import type { IAppServices, PartialAppServices } from "../../domain/interfaces/app-services.interface";
+import type { IAppServices, PartialAppServices } from "../../domain/interfaces/app-services-composite.interface";
 
 
 let appServices: IAppServices | null = null;

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

@@ -52,7 +52,7 @@ export abstract class BaseExecutor<TRequest, TResult, TOutput> {
     onProgress?: (progress: number) => void,
   ): Promise<unknown>;
   protected abstract validateExtractedResult(extracted: TOutput | undefined): string | undefined;
-  protected abstract transformResult(extracted: TOutput): TResult;
+  protected abstract transformResult(extracted: TOutput, request: TRequest): TResult;
   protected abstract getDefaultExtractor(): (result: unknown) => TOutput | undefined;
 
   private getProvider(): { provider: IAIProvider; error: null } | { provider: null; error: string } {
@@ -84,7 +84,7 @@ export abstract class BaseExecutor<TRequest, TResult, TOutput> {
       return failure(error);
     }
 
-    return success(this.transformResult(extracted as TOutput));
+    return success(this.transformResult(extracted as TOutput, request));
   }
 
   protected log(level: "info" | "error", message: string): void {

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

@@ -0,0 +1,131 @@
+/**
+ * Generation Orchestrator - Main Implementation
+ * Handles AI generation execution with network check, moderation, credit deduction, and error handling
+ */
+
+import { useCallback, useState, useRef } from "react";
+import type {
+  GenerationStatus,
+  GenerationState,
+  GenerationError,
+  GenerationStrategy,
+  GenerationConfig,
+  UseGenerationOrchestratorReturn,
+} from "./orchestrator-types";
+
+/**
+ * Main generation orchestrator hook
+ * Manages the complete generation lifecycle with error handling and state management
+ */
+export function useGenerationOrchestrator<TInput, TResult>(
+  strategy: GenerationStrategy<TInput, TResult>,
+  config: GenerationConfig,
+): UseGenerationOrchestratorReturn<TInput, TResult> {
+  const [status, setStatus] = useState<GenerationStatus>("idle");
+  const [result, setResult] = useState<TResult | null>(null);
+  const [error, setError] = useState<GenerationError | null>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const isGenerating = status === "checking" || status === "generating" || status === "saving";
+
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setResult(null);
+    setError(null);
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+  }, []);
+
+  const generate = useCallback(
+    async (input: TInput): Promise<TResult | void> => {
+      // Reset state
+      reset();
+
+      // Create abort controller for this generation
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+
+      try {
+        // Call lifecycle start hook
+        await config.lifecycle?.onStart?.();
+
+        // Set checking status
+        setStatus("checking");
+
+        // Execute generation
+        setStatus("generating");
+        const generationResult = await strategy.execute(input, abortController.signal);
+
+        // Save result if save strategy provided
+        if (strategy.save && config.userId) {
+          setStatus("saving");
+          await strategy.save(generationResult, config.userId);
+        }
+
+        // Success
+        setStatus("success");
+        setResult(generationResult);
+
+        // Call success callbacks
+        await config.onSuccess?.(generationResult);
+        await config.lifecycle?.onComplete?.("success", generationResult);
+
+        // Show success alert if provided
+        if (config.alertMessages?.success) {
+          // Alert would be shown here in a real implementation
+          console.log(config.alertMessages.success);
+        }
+
+        return generationResult;
+      } catch (err) {
+        // Determine error type and create error object
+        let errorType: GenerationError["type"] = "unknown";
+        let errorMessage = "An error occurred during generation";
+
+        if (err instanceof Error) {
+          if (err.message.includes("network") || err.message.includes("fetch")) {
+            errorType = "network";
+            errorMessage = config.alertMessages?.networkError || err.message;
+          } else if (err.message.includes("moderation") || err.message.includes("content")) {
+            errorType = "moderation";
+            errorMessage = config.alertMessages?.moderationError || err.message;
+          } else if (err.message.includes("credits") || err.message.includes("insufficient")) {
+            errorType = "credits";
+            errorMessage = config.alertMessages?.insufficientCredits || err.message;
+          } else if (err.message.includes("save") || err.message.includes("storage")) {
+            errorType = "save";
+            errorMessage = config.alertMessages?.saveFailed || err.message;
+          } else {
+            errorType = "generation";
+            errorMessage = config.alertMessages?.generationError || err.message;
+          }
+        }
+
+        const generationError: GenerationError = {
+          type: errorType,
+          message: errorMessage,
+          originalError: err instanceof Error ? err : undefined,
+        };
+
+        setStatus("error");
+        setError(generationError);
+
+        // Call error callbacks
+        await config.onError?.(generationError);
+        await config.lifecycle?.onComplete?.("error", undefined, generationError);
+      } finally {
+        abortControllerRef.current = null;
+      }
+    },
+    [strategy, config, reset],
+  );
+
+  return {
+    generate,
+    reset,
+    status,
+    isGenerating,
+    result,
+    error,
+  };
+}

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

@@ -71,8 +71,8 @@ export const useDualImageGeneration = (
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
-    onSuccess: (result) => onSuccess?.(result as string),
-    onError: (error) => onError?.(error.message),
+    onSuccess: async (result) => onSuccess?.(result as string),
+    onError: async (error) => onError?.(error.message),
   });
 
   // Process handler

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

@@ -88,7 +88,7 @@ export const useImageGeneration = <TInput extends ImageGenerationInput, TResult>
   return useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
-    onSuccess: onSuccess as (result: unknown) => void,
-    onError: handleError,
+    onSuccess: onSuccess ? async (result) => onSuccess(result) : undefined,
+    onError: async (error) => handleError(error),
   });
 };

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

@@ -103,7 +103,7 @@ export const useVideoGeneration = <TResult>(
   return useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
-    onSuccess: onSuccess as (result: unknown) => void,
-    onError: handleError,
+    onSuccess: onSuccess ? async (result) => onSuccess(result) : undefined,
+    onError: async (error) => handleError(error),
   });
 };

package/src/shared/hooks/factories/createGenerationHook.ts

@@ -0,0 +1,142 @@
+/**
+ * Generic Generation Hook Factory - Main Implementation
+ * Creates type-safe generation hooks with error handling, progress tracking, and abort support
+ */
+
+import { useState, useRef, useCallback, useEffect } from "react";
+import type {
+  GenerationState,
+  GenerationCallbacks,
+  GenerationHookConfig,
+  GenerationHookReturn,
+} from "./generation-hook-types";
+import {
+  INITIAL_STATE,
+  createAbortHandler,
+  createProgressSetter,
+  createErrorSetter,
+  createCleanupEffect,
+  createCallbackUpdater,
+} from "./generation-hook-utils";
+
+/**
+ * Creates a generation hook with standard configuration
+ */
+export function createGenerationHook<TRequest, TResult>(
+  defaultConfig: GenerationHookConfig<TRequest, TResult>) {
+  return function useGenerationHook(
+    request: TRequest | null,
+    callbacks?: GenerationCallbacks<TResult>,
+    configOverrides?: Partial<GenerationHookConfig<TRequest, TResult>>
+  ): GenerationHookReturn<TRequest, TResult> {
+    const config = { ...defaultConfig, ...configOverrides };
+    const [generationState, setGenerationState] = useState<GenerationState>(INITIAL_STATE);
+
+    const abortControllerRef = useRef<AbortController | null>(null);
+    const isMountedRef = useRef(true);
+
+    const onSuccessRef = useRef(callbacks?.onSuccess);
+    const onErrorRef = useRef(callbacks?.onError);
+    const onProgressRef = useRef(callbacks?.onProgress);
+
+    // Update callbacks when they change
+    useEffect(() => {
+      createCallbackUpdater(onSuccessRef, onErrorRef, onProgressRef, callbacks || {});
+    }, [callbacks]);
+
+    // Cleanup on unmount
+    useEffect(() => {
+      return createCleanupEffect(isMountedRef, abortControllerRef);
+    }, []);
+
+    const setProgress = createProgressSetter(
+      onProgressRef,
+      setGenerationState,
+      isMountedRef
+    );
+
+    const setError = createErrorSetter(
+      onErrorRef,
+      setGenerationState,
+      isMountedRef
+    );
+
+    const abort = createAbortHandler(abortControllerRef, setGenerationState);
+
+    const handleGenerate = useCallback(
+      async (req: TRequest): Promise<TResult | null> => {
+        // Validate if validator provided
+        if (config.validate) {
+          const validationError = config.validate(req);
+          if (validationError) {
+            setError(validationError);
+            return null;
+          }
+        }
+
+        setGenerationState((prev) => ({
+          ...prev,
+          isGenerating: true,
+          error: null,
+          progress: 0,
+        }));
+
+        try {
+          const abortController = new AbortController();
+          abortControllerRef.current = abortController;
+
+          const result = await config.execute(req, abortController.signal);
+
+          if (isMountedRef.current) {
+            setGenerationState((prev) => ({
+              ...prev,
+              isGenerating: false,
+              progress: 100,
+            }));
+            onSuccessRef.current?.(result);
+          }
+
+          return result;
+        } catch (err) {
+          if (!abortControllerRef.current?.signal.aborted && isMountedRef.current) {
+            const errorMessage = config.transformError
+              ? config.transformError(err)
+              : err instanceof Error
+              ? err.message
+              : "Generation failed";
+            setError(errorMessage);
+          }
+          return null;
+        } finally {
+          abortControllerRef.current = null;
+        }
+      },
+      [config, setError]
+    );
+
+    return {
+      generationState,
+      handleGenerate,
+      setProgress,
+      setError,
+      abort,
+    };
+  };
+}
+
+/**
+ * Creates a generation hook with built-in progress tracking
+ */
+export function createGenerationHookWithProgress<TRequest, TResult>(
+  defaultConfig: GenerationHookConfig<TRequest, TResult>
+) {
+  return function useGenerationWithProgress(
+    request: TRequest | null,
+    callbacks?: GenerationCallbacks<TResult>,
+    configOverrides?: Partial<GenerationHookConfig<TRequest, TResult>>
+  ): GenerationHookReturn<TRequest, TResult> {
+    // Reuse the standard hook
+    const useStandardHook = createGenerationHook(defaultConfig);
+    return useStandardHook(request, callbacks, configOverrides);
+  };
+}

package/src/shared-kernel/infrastructure/validation/index.ts

@@ -2,13 +2,19 @@
  * Shared Validation Utilities
  */
 
-// Export types from base-validator.types
-export type {
+import type {
   ValidationResult,
   StringValidationOptions,
   NumericValidationOptions,
 } from "../../../infrastructure/validation/base-validator.types";
 
+// Re-export types
+export type {
+  ValidationResult,
+  StringValidationOptions,
+  NumericValidationOptions,
+};
+
 // Export functions from advanced-validator
 export { combineValidationResults } from "../../../infrastructure/validation/advanced-validator";