@umituz/react-native-ai-generation-content 1.84.12 → 1.84.14

package/package.json

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

package/src/domains/creations/domain/entities/Creation.ts

@@ -88,7 +88,7 @@ export function mapDocumentToCreation(
 ): Creation {
   const creationDate = toDate(data.createdAt) ?? new Date();
 
-  const uri = data.output?.imageUrl || data.output?.videoUrl || data.uri || "";
+  const uri = data.output?.imageUrl || data.output?.videoUrl || data.output?.audioUrl || data.uri || "";
 
   return {
     id,

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

@@ -56,7 +56,7 @@ export function GalleryResultPreview({
     onSaveError: () => alert.show(AlertType.ERROR, AlertMode.TOAST, t("common.error"), t("result.saveError")),
   });
 
-  const hasRating = selectedCreation.rating !== undefined && selectedCreation.rating !== null;
+  const hasRating = selectedCreation.rating !== undefined;
 
   return (
     <>

package/src/domains/creations/presentation/screens/creations-gallery.types.ts

@@ -22,7 +22,7 @@ export interface CreationsGalleryScreenProps {
   /** Function to get dynamic title from creation metadata */
   readonly getCreationTitle?: (creation: { type: string; metadata?: Record<string, unknown> }) => string;
   /** Custom handler when a creation card is pressed. When provided, overrides the built-in preview. */
-  readonly onCreationPress?: (creation: { id: string; uri: string; type: string; originalUri?: string; output?: { imageUrl?: string; videoUrl?: string }; metadata?: Record<string, unknown> }) => void;
+  readonly onCreationPress?: (creation: { id: string; uri: string; type: string; originalUri?: string; output?: { imageUrl?: string; videoUrl?: string; audioUrl?: string }; metadata?: Record<string, unknown> }) => void;
   /** Called when the user taps the Edit button in the creation detail view. Receives the image URL. Only shown for image creations. */
   readonly onEdit?: (imageUrl: string) => void;
   /** Called when the user taps the Edit button in the creation detail view. Receives the video URL. Only shown for video creations. */

package/src/domains/generation/index.ts

@@ -54,6 +54,7 @@ export type {
   UseWizardGenerationReturn,
   WizardScenarioData,
   WizardOutputType,
+  WizardAudioInput,
   GenericWizardFlowProps,
   TextInputScreenTranslations,
   TextInputScreenConfig,
@@ -75,6 +76,10 @@ export {
   TEXT_TO_IMAGE_WIZARD_CONFIG,
   TEXT_TO_VIDEO_WIZARD_CONFIG,
   IMAGE_TO_VIDEO_WIZARD_CONFIG,
+  // Audio generation
+  buildAudioInput,
+  createAudioStrategy,
+  executeAudioGeneration,
 } from "./wizard";
 
 // Flow Infrastructure

package/src/domains/generation/wizard/index.ts

@@ -80,6 +80,11 @@ export type {
   AudioPickerScreenProps,
 } from "./presentation/screens";
 
+// Audio Generation Types
+export type { WizardAudioInput } from "./infrastructure/strategies/audio-generation.types";
+export { buildAudioInput, createAudioStrategy } from "./infrastructure/strategies/audio-generation.strategy";
+export { executeAudioGeneration } from "./infrastructure/strategies/audio-generation.executor";
+
 // Feature Configs
 export {
   TEXT_TO_IMAGE_WIZARD_CONFIG,

package/src/domains/generation/wizard/infrastructure/strategies/audio-generation.executor.ts

@@ -0,0 +1,113 @@
+/**
+ * Audio Generation Executor
+ * Handles TTS generation via the AI provider (model-agnostic).
+ * The model endpoint (e.g., Chatterbox) is configured in the main app.
+ */
+
+import type { WizardAudioInput } from "./audio-generation.types";
+import { addGenerationLogs, addGenerationLog, startGenerationLogSession } from "../../../../../infrastructure/services/generation-log-store";
+
+/** Audio generation timeout — TTS is typically fast (10-30s) */
+const AUDIO_GENERATION_TIMEOUT_MS = 60_000;
+
+interface AudioExecutionResult {
+  success: boolean;
+  audioUrl?: string;
+  error?: string;
+  logSessionId?: string;
+}
+
+export async function executeAudioGeneration(
+  input: WizardAudioInput,
+  model: string,
+  onProgress?: (progress: number) => void,
+  providerId?: string,
+): Promise<AudioExecutionResult> {
+  const TAG = "AudioExecutor";
+  const startTime = Date.now();
+  const sid = startGenerationLogSession();
+  const { resolveProvider } = await import("../../../../../infrastructure/services/provider-resolver");
+
+  let provider;
+  try {
+    provider = resolveProvider(providerId);
+  } catch {
+    addGenerationLog(sid, TAG, "Provider not initialized!", "error");
+    return { success: false, error: "AI provider not initialized", logSessionId: sid };
+  }
+
+  try {
+    addGenerationLog(sid, TAG, "TTS generation starting", "info", {
+      model,
+      textLength: input.text.length,
+      voice: input.voice,
+      language: input.language,
+      timeout: AUDIO_GENERATION_TIMEOUT_MS,
+    });
+
+    // Build model input — generic structure, model-specific params come from app config
+    const modelInput: Record<string, unknown> = {
+      text: input.text,
+    };
+
+    if (input.voice) {
+      modelInput.voice = input.voice;
+    }
+    if (input.language) {
+      modelInput.language = input.language;
+    }
+    if (input.exaggeration !== undefined) {
+      modelInput.exaggeration = input.exaggeration;
+    }
+    if (input.cfgWeight !== undefined) {
+      modelInput.cfg_weight = input.cfgWeight;
+    }
+
+    addGenerationLog(sid, TAG, "Calling provider.subscribe()...");
+    const result = await provider.subscribe(model, modelInput, {
+      timeoutMs: AUDIO_GENERATION_TIMEOUT_MS,
+      onQueueUpdate: (status) => {
+        addGenerationLog(sid, TAG, `Queue: ${status.status}`);
+      },
+    });
+
+    // Collect provider logs
+    const providerSessionId = (result as { __providerSessionId?: string })?.__providerSessionId;
+    const providerLogs = provider.endLogSession?.(providerSessionId) ?? provider.getSessionLogs?.(providerSessionId) ?? [];
+    addGenerationLogs(sid, providerLogs);
+
+    // Extract audio URL from response
+    // FAL TTS models return: { audio: { url } } or { audio_url } or { url }
+    const rawResult = result as Record<string, unknown>;
+    const data = (rawResult?.data ?? rawResult) as {
+      audio?: { url: string };
+      audio_url?: string;
+      url?: string;
+    };
+
+    const audioUrl = data?.audio?.url ?? data?.audio_url ?? data?.url;
+
+    const elapsed = Date.now() - startTime;
+    onProgress?.(100);
+
+    if (audioUrl) {
+      addGenerationLog(sid, TAG, `TTS SUCCESS in ${elapsed}ms`, "info", { audioUrl, elapsed });
+      return { success: true, audioUrl, logSessionId: sid };
+    }
+
+    addGenerationLog(sid, TAG, `No audio in response after ${elapsed}ms`, "error", {
+      responseKeys: Object.keys(data || {}),
+      elapsed,
+    });
+    return { success: false, error: "No audio generated", logSessionId: sid };
+  } catch (error) {
+    // Collect provider logs even on failure
+    const providerLogs = provider.endLogSession?.() ?? [];
+    addGenerationLogs(sid, providerLogs);
+
+    const elapsed = Date.now() - startTime;
+    const errorMsg = error instanceof Error ? error.message : "Audio generation failed";
+    addGenerationLog(sid, TAG, `TTS FAILED after ${elapsed}ms: ${errorMsg}`, "error", { elapsed });
+    return { success: false, error: errorMsg, logSessionId: sid };
+  }
+}

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

@@ -0,0 +1,97 @@
+/**
+ * Audio Generation Strategy
+ * Handles TTS-specific generation logic (execution only)
+ */
+
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+import type { WizardStrategy } from "./wizard-strategy.types";
+import type { WizardAudioInput, CreateAudioStrategyOptions } from "./audio-generation.types";
+import { executeAudioGeneration } from "./audio-generation.executor";
+
+// ============================================================================
+// Input Builder
+// ============================================================================
+
+export function buildAudioInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): WizardAudioInput {
+  // Extract text from wizard data (TEXT_INPUT step stores as "text" or "prompt")
+  const text =
+    typeof wizardData.text === "string"
+      ? wizardData.text
+      : typeof wizardData.prompt === "string"
+        ? wizardData.prompt
+        : "";
+
+  if (!text.trim()) {
+    throw new Error("Text is required for audio generation");
+  }
+
+  // Extract voice selection from wizard data
+  const voice =
+    typeof wizardData.voice === "string"
+      ? wizardData.voice
+      : typeof wizardData.selectedVoice === "string"
+        ? wizardData.selectedVoice
+        : typeof scenario.voice === "string"
+          ? scenario.voice
+          : undefined;
+
+  // Extract optional parameters
+  const language =
+    typeof wizardData.language === "string"
+      ? wizardData.language
+      : typeof scenario.language === "string"
+        ? scenario.language
+        : undefined;
+
+  const exaggeration =
+    typeof wizardData.exaggeration === "number"
+      ? wizardData.exaggeration
+      : typeof scenario.exaggeration === "number"
+        ? scenario.exaggeration
+        : undefined;
+
+  const cfgWeight =
+    typeof wizardData.cfgWeight === "number"
+      ? wizardData.cfgWeight
+      : typeof scenario.cfgWeight === "number"
+        ? scenario.cfgWeight
+        : undefined;
+
+  return { text, voice, language, exaggeration, cfgWeight };
+}
+
+// ============================================================================
+// Strategy Factory
+// ============================================================================
+
+export function createAudioStrategy(options: CreateAudioStrategyOptions): WizardStrategy {
+  const { scenario } = options;
+
+  if (!scenario.model) {
+    throw new Error("Model is required for audio generation");
+  }
+
+  const model = scenario.model;
+  const providerId = scenario.providerId;
+
+  return {
+    execute: async (input: unknown) => {
+      if (!input || typeof input !== "object") {
+        throw new Error("Invalid input: expected WizardAudioInput object");
+      }
+      const audioInput = input as WizardAudioInput;
+      const result = await executeAudioGeneration(audioInput, model, undefined, providerId);
+
+      if (!result.success || !result.audioUrl) {
+        const error = new Error(result.error || "Audio generation failed");
+        (error as Error & { logSessionId?: string }).logSessionId = result.logSessionId;
+        throw error;
+      }
+
+      return { audioUrl: result.audioUrl, logSessionId: result.logSessionId };
+    },
+  };
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Wizard Audio Generation Types
+ * Type definitions for wizard audio generation strategy (TTS)
+ */
+
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+
+export interface WizardAudioInput {
+  /** Text content to convert to speech */
+  readonly text: string;
+  /** Voice preset name (model-specific) */
+  readonly voice?: string;
+  /** Language code (e.g., "en", "es") */
+  readonly language?: string;
+  /** Exaggeration factor for voice expressiveness (0.0 - 1.0) */
+  readonly exaggeration?: number;
+  /** CFG/pace control weight */
+  readonly cfgWeight?: number;
+}
+
+export interface CreateAudioStrategyOptions {
+  readonly scenario: WizardScenarioData;
+  readonly collectionName?: string;
+  /** Credit cost for this generation - REQUIRED, determined by the app */
+  readonly creditCost: number;
+}

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.executor.ts

@@ -80,14 +80,11 @@ export async function executeImageGeneration(
       modelInput.image_urls = imageUrls;
     }
 
-    let lastStatus = "";
     addGenerationLog(sid, TAG, 'Calling provider.subscribe()...');
     const result = await provider.subscribe(model, modelInput, {
       timeoutMs: GENERATION_TIMEOUT_MS,
       onQueueUpdate: (status) => {
-        if (status.status !== lastStatus) {
-          lastStatus = status.status;
-        }
+        addGenerationLog(sid, TAG, `Queue: ${status.status}`);
       },
     });
 

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

@@ -88,6 +88,9 @@ export function createImageStrategy(options: CreateImageStrategyOptions): Wizard
 
   return {
     execute: async (input: unknown) => {
+      if (!input || typeof input !== "object") {
+        throw new Error("Invalid input: expected WizardImageInput object");
+      }
       const imageInput = input as WizardImageInput;
       const result = await executeImageGeneration(imageInput, model, undefined, providerId);
 

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

@@ -32,9 +32,7 @@ async function extractAudioAsBase64(wizardData: Record<string, unknown>): Promis
     }
     return base64;
   } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.warn("[VideoStrategy] Failed to read audio file:", error);
-    }
+    console.warn("[VideoStrategy] Failed to read audio file:", error);
     return undefined;
   }
 }

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

@@ -56,6 +56,14 @@ export function validatePhotoCount(
       break;
     case "text":
       break;
+    default: {
+      // Exhaustive check: log unexpected input types in development
+      const _exhaustive: never = effectiveInputType;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn(`[validatePhotoCount] Unknown inputType: ${_exhaustive}`);
+      }
+      break;
+    }
   }
 
   return { isValid: true };

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

@@ -9,6 +9,7 @@ import type { WizardStrategy } from "./wizard-strategy.types";
 import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 import { createImageStrategy, buildImageInput } from "./image-generation.strategy";
 import { createVideoStrategy, buildVideoInput } from "./video-generation.strategy";
+import { createAudioStrategy, buildAudioInput } from "./audio-generation.strategy";
 
 // ============================================================================
 // Types
@@ -34,6 +35,10 @@ export function createWizardStrategy(options: CreateWizardStrategyOptions): Wiza
     return createImageStrategy({ scenario, collectionName, creditCost });
   }
 
+  if (scenario.outputType === "audio") {
+    return createAudioStrategy({ scenario, collectionName, creditCost });
+  }
+
   // Default to video strategy for video outputType or undefined
   return createVideoStrategy({ scenario, modelConfig, collectionName, creditCost });
 }
@@ -47,9 +52,21 @@ export async function buildWizardInput(
   scenario: WizardScenarioData,
 ): Promise<unknown> {
   if (scenario.outputType === "image") {
-    return buildImageInput(wizardData, scenario);
+    const input = await buildImageInput(wizardData, scenario);
+    if (!input) {
+      throw new Error("Failed to build image input");
+    }
+    return input;
+  }
+
+  if (scenario.outputType === "audio") {
+    return buildAudioInput(wizardData, scenario);
   }
 
   // Default to video input for video outputType or undefined
-  return buildVideoInput(wizardData, scenario);
+  const input = await buildVideoInput(wizardData, scenario);
+  if (!input) {
+    throw new Error("Failed to build video input");
+  }
+  return input;
 }

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

@@ -12,7 +12,7 @@ export interface QueueSubmissionResult {
 
 export interface WizardStrategy {
   /** Execute the generation - returns result with URLs (blocking) */
-  execute: (input: unknown) => Promise<{ imageUrl?: string; videoUrl?: string }>;
+  execute: (input: unknown) => Promise<{ imageUrl?: string; videoUrl?: string; audioUrl?: string; logSessionId?: string }>;
   /** Submit to queue for background processing - returns immediately with requestId */
   submitToQueue?: (input: unknown) => Promise<QueueSubmissionResult>;
 }

package/src/domains/generation/wizard/infrastructure/utils/creation-persistence.types.ts

@@ -21,6 +21,7 @@ export interface CompletedCreationData {
   readonly uri: string;
   readonly imageUrl?: string;
   readonly videoUrl?: string;
+  readonly audioUrl?: string;
   readonly thumbnailUrl?: string;
   /** Unix timestamp (ms) when generation was submitted; used to compute durationMs */
   readonly generationStartedAt?: number;

package/src/domains/generation/wizard/infrastructure/utils/creation-update-operations.ts

@@ -53,19 +53,22 @@ export async function updateToCompleted(
   const output: CreationOutput = {
     ...(data.imageUrl && { imageUrl: data.imageUrl }),
     ...(data.videoUrl && { videoUrl: data.videoUrl }),
+    ...(data.audioUrl && { audioUrl: data.audioUrl }),
     ...(data.thumbnailUrl && { thumbnailUrl: data.thumbnailUrl }),
   };
 
   const completedAt = new Date();
-  const durationMs =
+  const rawDuration =
     data.generationStartedAt !== undefined
       ? completedAt.getTime() - data.generationStartedAt
       : undefined;
+  const durationMs = rawDuration !== undefined && rawDuration >= 0 ? rawDuration : undefined;
+  const hasOutput = Object.keys(output).length > 0;
 
   await repository.update(userId, creationId, {
     uri: data.uri,
     status: "completed" as const,
-    output,
+    ...(hasOutput && { output }),
     completedAt,
     ...(durationMs !== undefined && { durationMs }),
   } as Partial<Creation>);

package/src/domains/generation/wizard/presentation/components/WizardStepRenderer.tsx

@@ -61,7 +61,7 @@ export const WizardStepRenderer: React.FC<WizardStepRendererProps> = ({
       const media = extractMediaUrl(generationResult);
       if (!media) return null;
       const isVideo = media.isVideo || getMediaTypeFromUrl(media.url) === "video";
-      const handleTryAgain = onTryAgain ?? onBack;
+      const handleTryAgain = onTryAgain ?? onBack ?? (() => {});
       return (
         <ResultPreviewScreen
           imageUrl={isVideo ? undefined : media.url}

package/src/domains/generation/wizard/presentation/components/WizardStepRenderer.utils.ts

@@ -11,7 +11,8 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function isWizardStepConfig(value: unknown): value is WizardStepConfig {
-  return isRecord(value);
+  if (!isRecord(value)) return false;
+  return typeof value.id === "string" && typeof value.type === "string";
 }
 
 function isUploadedImage(value: unknown): value is UploadedImage {

package/src/domains/generation/wizard/presentation/components/step-renderers/renderAudioPickerStep.tsx

@@ -26,7 +26,7 @@ export function renderAudioPickerStep({
 }: AudioPickerStepProps): React.ReactElement {
   const audioConfig = getAudioPickerConfig(step.config);
   const titleKey = audioConfig?.titleKey ?? `wizard.steps.${step.id}.title`;
-  const subtitleKey = audioConfig?.subtitleKey ?? `wizard.steps.${step.id}.subtitle`;
+  const subtitleKey = audioConfig?.subtitleKey;
   const isOptional = !(step.required ?? true);
 
   return (

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

@@ -45,21 +45,24 @@ export function usePhotoBlockingGeneration(
     alertMessages,
     onSuccess,
     onError,
+    onCreditsExhausted,
   } = props;
 
   const creationIdRef = useRef<string | null>(null);
 
   const handleSuccess = useCallback(
     async (result: unknown) => {
-      const typedResult = result as { imageUrl?: string; videoUrl?: string; logSessionId?: string };
+      const typedResult = result as { imageUrl?: string; videoUrl?: string; audioUrl?: string; logSessionId?: string };
       const creationId = creationIdRef.current;
+      const resultUri = typedResult.imageUrl || typedResult.videoUrl || typedResult.audioUrl;
 
-      if (creationId && userId) {
+      if (creationId && userId && resultUri) {
         try {
           await persistence.updateToCompleted(userId, creationId, {
-            uri: typedResult.imageUrl || typedResult.videoUrl || "",
+            uri: resultUri,
             imageUrl: typedResult.imageUrl,
             videoUrl: typedResult.videoUrl,
+            audioUrl: typedResult.audioUrl,
             logSessionId: typedResult.logSessionId,
           });
         } catch (err) {
@@ -73,16 +76,21 @@ export function usePhotoBlockingGeneration(
 
       // Deduct credits after successful generation
       if (deductCredits && creditCost) {
-        await deductCredits(creditCost).catch((err) => {
+        try {
+          const deducted = await deductCredits(creditCost);
+          if (!deducted) {
+            onCreditsExhausted?.();
+          }
+        } catch (err) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.error("[PhotoBlockingGeneration] deductCredits error:", err);
           }
-        });
+        }
       }
 
       onSuccess?.(result);
     },
-    [userId, persistence, deductCredits, creditCost, onSuccess],
+    [userId, persistence, deductCredits, creditCost, onSuccess, onCreditsExhausted],
   );
 
   const handleError = useCallback(
@@ -133,7 +141,7 @@ export function usePhotoBlockingGeneration(
             resolution,
             creditCost,
             aspectRatio,
-            provider: "fal",
+            provider: scenario.providerId ?? "fal",
             outputType: scenario.outputType,
           });
           creationIdRef.current = result.creationId;

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

@@ -7,7 +7,7 @@ import type { AlertMessages } from "../../../../../presentation/hooks/generation
 import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
 import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 
-export type WizardOutputType = "image" | "video";
+export type WizardOutputType = "image" | "video" | "audio";
 
 export interface WizardScenarioData {
   readonly id: string;

package/src/domains/generation/wizard/presentation/screens/AudioPickerScreen.tsx

@@ -91,7 +91,7 @@ export const AudioPickerScreen: React.FC<AudioPickerScreenProps> = ({
   }, [onContinue]);
 
   const formatFileSize = useCallback((bytes?: number) => {
-    if (!bytes) return "";
+    if (bytes === undefined || bytes === null) return "";
     if (bytes < 1024) return `${bytes} B`;
     if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
     return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
@@ -101,7 +101,7 @@ export const AudioPickerScreen: React.FC<AudioPickerScreenProps> = ({
   const styles = useMemo(() => createStyles(tokens), [tokens]);
 
   return (
-    <View style={{ flex: 1, backgroundColor: tokens.colors.backgroundPrimary }}>
+    <View style={[styles.root, { backgroundColor: tokens.colors.backgroundPrimary }]}>
       <NavigationHeader
         title=""
         onBackPress={onBack}
@@ -183,6 +183,9 @@ export const AudioPickerScreen: React.FC<AudioPickerScreenProps> = ({
 
 const createStyles = (tokens: DesignTokens) =>
   StyleSheet.create({
+    root: {
+      flex: 1,
+    },
     scrollContent: {
       paddingHorizontal: tokens.spacing.lg,
       paddingBottom: 40,

package/src/domains/result-preview/presentation/components/ResultPreviewScreen.tsx

@@ -85,13 +85,13 @@ export const ResultPreviewScreen: React.FC<ResultPreviewScreenProps> = ({
             showRating={showRating}
           />
         </View>
-        {showRecent && (
+        {showRecent && recentCreations && translations.recentCreations && translations.viewAll && (
           <RecentCreationsSection
-            recentCreations={recentCreations!}
+            recentCreations={recentCreations}
             onViewAll={onViewAll}
             onCreationPress={onCreationPress}
-            title={translations.recentCreations!}
-            viewAllLabel={translations.viewAll!}
+            title={translations.recentCreations}
+            viewAllLabel={translations.viewAll}
           />
         )}
       </View>

package/src/domains/result-preview/presentation/types/result-components.types.ts

@@ -29,7 +29,7 @@ export interface ResultActionBarProps {
   /** Share callback */
   onShare: () => void;
   /** Try again callback */
-  onTryAgain: () => void;
+  onTryAgain?: () => void;
   /** Rate callback */
   onRate?: () => void;
   /** Save button text */

package/src/domains/result-preview/presentation/types/result-screen.types.ts

@@ -19,8 +19,8 @@ export interface ResultPreviewScreenProps {
   /** Action callbacks */
   onDownload: () => void;
   onShare: () => void;
-  onTryAgain: () => void;
-  onNavigateBack: () => void;
+  onTryAgain?: () => void;
+  onNavigateBack?: () => void;
   onRate?: () => void;
   /** Edit callback — opens photo editor for the result image */
   onEdit?: () => void;

package/src/domains/scenarios/domain/Scenario.ts

@@ -4,7 +4,7 @@
  * Note: ScenarioId and ScenarioCategory should be defined in the app, not here
  */
 
-export type ScenarioOutputType = "image" | "video";
+export type ScenarioOutputType = "image" | "video" | "audio";
 
 export type ScenarioInputType = "single" | "dual" | "text";
 

package/src/exports/presentation.ts

@@ -9,7 +9,7 @@ export {
   useGenerationFlow, useAIFeatureCallbacks,
   useAIGenerateState, AIGenerateStep,
   useGenerationOrchestrator, useImageGeneration, useVideoGeneration, useDualImageGeneration,
-  useImagePicker, useImageGenerationExecutor,
+  useImagePicker, useImageGenerationExecutor, useAudioGenerationExecutor,
   createGenerationError, getAlertMessage, parseError,
 } from "../presentation/hooks";
 export type {
@@ -26,6 +26,7 @@ export type {
   UploadedImage,
   GenerationTarget, GenerationInput, AIImageResult,
   ImageGenerationExecutorConfig, ImageGenerationExecutorReturn,
+  AudioGenerationInput, AudioGenerationExecutorConfig, AudioGenerationExecutorReturn,
 } from "../presentation/hooks";
 
 // Components

package/src/index.ts

@@ -31,7 +31,10 @@ export {
   IMAGE_TO_VIDEO_WIZARD_CONFIG,
   SOLO_VIDEO_WIZARD_CONFIG,
 } from "./domains/generation/wizard";
-export type { WizardScenarioData } from "./domains/generation/wizard";
+export type { WizardScenarioData, WizardAudioInput } from "./domains/generation/wizard";
+
+// Audio Generation (TTS)
+export { executeAudioGeneration, buildAudioInput, createAudioStrategy } from "./domains/generation/wizard";
 
 // Wizard Validators and Credit Utilities
 export {

package/src/infrastructure/providers/generation-services.provider.tsx

@@ -12,7 +12,7 @@ import React, {
 } from "react";
 
 export interface GenerationServicesValue {
-  /** Current authenticated user ID (null = not authenticated) */
+  /** Current authenticated user ID (undefined = not authenticated) */
   readonly userId: string | undefined;
   /** Deduct credits. Returns true if successful, false if insufficient. */
   readonly deductCredits: (cost: number) => Promise<boolean>;

package/src/infrastructure/utils/couple-input.util.ts

@@ -1,7 +1,11 @@
-import type { GenerationTarget } from "../../presentation/hooks/generation/useImageGenerationExecutor";
+/** Target for generation: which model on which provider */
+interface GenerationTargetLike {
+  readonly model: string;
+  readonly providerId: string;
+}
 
 interface CoupleInputResult {
-  readonly target: GenerationTarget;
+  readonly target: GenerationTargetLike;
   readonly imageUrls: string[];
 }
 
@@ -13,8 +17,8 @@ export function resolveCoupleInput(
   partner1PhotoUri: string,
   partner2PhotoUri: string | null,
   isCoupleMode: boolean,
-  singleTarget: GenerationTarget,
-  coupleTarget: GenerationTarget,
+  singleTarget: GenerationTargetLike,
+  coupleTarget: GenerationTargetLike,
 ): CoupleInputResult {
   if (isCoupleMode && partner2PhotoUri) {
     return {

package/src/infrastructure/utils/image-input-preprocessor.util.ts

@@ -0,0 +1,87 @@
+/**
+ * Image Input Preprocessor
+ *
+ * Converts local file URIs (file://, ph://, content://) to base64 strings
+ * before passing params to any AI provider. This ensures providers only
+ * receive base64 or HTTPS URLs — never platform-specific file URIs.
+ *
+ * Uses @umituz/react-native-design-system/filesystem for file I/O.
+ * Used by useImageGenerationExecutor to preprocess params automatically.
+ */
+
+import { readFileAsBase64 } from "@umituz/react-native-design-system/filesystem";
+
+const LOCAL_URI_PREFIXES = ["file://", "ph://", "content://"];
+
+const isLocalFileUri = (value: unknown): value is string =>
+  typeof value === "string" &&
+  LOCAL_URI_PREFIXES.some((p) => value.startsWith(p));
+
+/** Known field names that may contain image URIs */
+const IMAGE_FIELDS = [
+  "image",
+  "image_url",
+  "image_urls",
+  "images",
+  "reference_image",
+  "source_image",
+  "target_image",
+  "driver_image_url",
+  "face_image",
+  "mask_image",
+] as const;
+
+/**
+ * Read a local file URI as base64.
+ */
+async function readLocalUri(uri: string): Promise<string> {
+  const result = await readFileAsBase64(uri);
+  if (!result) throw new Error(`Failed to read file: ${uri}`);
+  return result;
+}
+
+/**
+ * Resolve a single value: convert local file URI to base64, pass others through.
+ */
+async function resolveValue(value: string): Promise<string> {
+  return isLocalFileUri(value) ? readLocalUri(value) : value;
+}
+
+/**
+ * Preprocess generation params: scan known image fields and convert
+ * local file URIs to base64. Returns a new object (never mutates input).
+ */
+export async function preprocessImageInputs(
+  params: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  const result = { ...params };
+  let converted = 0;
+
+  for (const field of IMAGE_FIELDS) {
+    const value = result[field];
+    if (value === undefined || value === null) continue;
+
+    if (typeof value === "string" && isLocalFileUri(value)) {
+      result[field] = await resolveValue(value);
+      converted++;
+    } else if (Array.isArray(value)) {
+      const hasLocalUri = value.some(isLocalFileUri);
+      if (hasLocalUri) {
+        result[field] = await Promise.all(
+          value.map((v) =>
+            typeof v === "string" ? resolveValue(v) : v,
+          ),
+        );
+        converted++;
+      }
+    }
+  }
+
+  if (converted > 0 && typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log(
+      `[ImagePreprocessor] Converted ${converted} field(s) from file URI to base64`,
+    );
+  }
+
+  return result;
+}

package/src/infrastructure/utils/intensity.util.ts

@@ -1,6 +1,9 @@
 /**
  * Maps a 0-100 intensity slider value to AI model strength parameter.
  * Range: 0→0.30, 50→0.61, 100→0.92
+ * Input is clamped to [0, 100].
  */
-export const intensityToStrength = (intensity: number): number =>
-  0.3 + (intensity / 100) * 0.62;
+export const intensityToStrength = (intensity: number): number => {
+  const clamped = Math.max(0, Math.min(100, intensity));
+  return 0.3 + (clamped / 100) * 0.62;
+};

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

@@ -57,6 +57,14 @@ export type {
   ImageGenerationExecutorReturn,
 } from "./useImageGenerationExecutor";
 
+// Standalone audio generation executor (Template Method Pattern)
+export { useAudioGenerationExecutor } from "./useAudioGenerationExecutor";
+export type {
+  AudioGenerationInput,
+  AudioGenerationExecutorConfig,
+  AudioGenerationExecutorReturn,
+} from "./useAudioGenerationExecutor";
+
 // Error utilities
 export {
   createGenerationError,

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

@@ -0,0 +1,149 @@
+/**
+ * Audio Generation Executor Hook (Template Method Pattern)
+ *
+ * Mirrors useImageGenerationExecutor but for TTS/audio generation.
+ * Encapsulates: auth → credit deduction → provider call → creation save → error/refund
+ *
+ * Consumers provide domain-specific logic via config:
+ *   - buildInput: text, voice, target (model + provider)
+ *   - buildMetadata: creation metadata
+ */
+
+import { useState, useCallback, useMemo } from "react";
+import { useGenerationServices } from "../../../infrastructure/providers/generation-services.provider";
+import { resolveProvider } from "../../../infrastructure/services/provider-resolver";
+import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import type { GenerationTarget } from "./useImageGenerationExecutor";
+
+/** Domain-specific audio generation input returned by buildInput */
+export interface AudioGenerationInput {
+  /** Which model + provider to use */
+  readonly target: GenerationTarget;
+  /** The text being converted to speech (stored in creation record) */
+  readonly prompt: string;
+  /** Full params passed to provider.subscribe() */
+  readonly params: Record<string, unknown>;
+}
+
+/** Provider-agnostic AI audio result */
+interface AIAudioResult {
+  readonly audio?: { readonly url: string };
+  readonly audio_url?: string;
+  readonly url?: string;
+}
+
+/** Default credit cost for audio generation */
+const DEFAULT_AUDIO_CREDIT_COST = 1;
+
+export interface AudioGenerationExecutorConfig<P> {
+  /** Creation type stored in Firestore (e.g. "voice-generator") */
+  readonly type: string;
+  /** Credit cost per generation. Defaults to 1. */
+  readonly creditCost?: number;
+  /** Whether to call onGenerationSuccess after completion */
+  readonly trackRating?: boolean;
+  /** Build AI generation input from domain-specific params. May be async. */
+  readonly buildInput: (params: P) => Promise<AudioGenerationInput> | AudioGenerationInput;
+  /** Build domain-specific metadata for the creation record */
+  readonly buildMetadata?: (params: P) => Record<string, unknown>;
+}
+
+export interface AudioGenerationExecutorReturn<P> {
+  readonly execute: (params: P) => Promise<string | null>;
+  readonly isLoading: boolean;
+  readonly error: string | null;
+}
+
+export function useAudioGenerationExecutor<P>(
+  config: AudioGenerationExecutorConfig<P>,
+): AudioGenerationExecutorReturn<P> {
+  const { userId, deductCredits, refundCredits, onGenerationSuccess } =
+    useGenerationServices();
+  const repository = useMemo(
+    () => createCreationsRepository("creations"),
+    [],
+  );
+  const [error, setError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const execute = useCallback(
+    async (params: P): Promise<string | null> => {
+      if (!userId || isLoading) return null;
+
+      setError(null);
+      setIsLoading(true);
+      let deducted = false;
+      const cost = config.creditCost ?? DEFAULT_AUDIO_CREDIT_COST;
+
+      try {
+        const creditSuccess = await deductCredits(cost);
+        if (!creditSuccess) {
+          setError("Insufficient credits");
+          return null;
+        }
+        deducted = true;
+
+        const input = await config.buildInput(params);
+        const provider = resolveProvider(input.target.providerId);
+        const result = (await provider.subscribe(
+          input.target.model,
+          input.params,
+        )) as AIAudioResult;
+
+        // Extract audio URL — FAL returns { audio: { url } }, some models { audio_url } or { url }
+        const audioUrl = result?.audio?.url ?? result?.audio_url ?? result?.url;
+        if (!audioUrl) throw new Error("No audio returned");
+
+        await repository.create(userId, {
+          id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+          type: config.type,
+          uri: audioUrl,
+          createdAt: new Date(),
+          isShared: false,
+          isFavorite: false,
+          status: "completed",
+          output: { audioUrl },
+          model: input.target.model,
+          prompt: input.prompt,
+          metadata: config.buildMetadata?.(params) ?? {},
+        });
+
+        if (config.trackRating && onGenerationSuccess) {
+          void onGenerationSuccess();
+        }
+
+        return audioUrl;
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Generation failed";
+        setError(message);
+        if (deducted) {
+          try {
+            await refundCredits(cost);
+          } catch {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.error(`[${config.type}] Refund failed`);
+            }
+          }
+        }
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error(`[${config.type}]`, err);
+        }
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [
+      userId,
+      isLoading,
+      config,
+      deductCredits,
+      refundCredits,
+      repository,
+      onGenerationSuccess,
+    ],
+  );
+
+  return { execute, isLoading, error };
+}

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

@@ -15,6 +15,7 @@ import { useState, useCallback, useMemo } from "react";
 import { useGenerationServices } from "../../../infrastructure/providers/generation-services.provider";
 import { resolveProvider } from "../../../infrastructure/services/provider-resolver";
 import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import { preprocessImageInputs } from "../../../infrastructure/utils/image-input-preprocessor.util";
 
 /** Target for generation: which model on which provider */
 export interface GenerationTarget {
@@ -73,7 +74,7 @@ export function useImageGenerationExecutor<P>(
 
   const execute = useCallback(
     async (params: P): Promise<string | null> => {
-      if (!userId) return null;
+      if (!userId || isLoading) return null;
 
       setError(null);
       setIsLoading(true);
@@ -90,9 +91,10 @@ export function useImageGenerationExecutor<P>(
 
         const input = await config.buildInput(params);
         const provider = resolveProvider(input.target.providerId);
+        const processedParams = await preprocessImageInputs(input.params);
         const result = (await provider.subscribe(
           input.target.model,
-          input.params,
+          processedParams,
         )) as AIImageResult;
 
         const imageUrl = result?.images?.[0]?.url;
@@ -140,6 +142,7 @@ export function useImageGenerationExecutor<P>(
     },
     [
       userId,
+      isLoading,
       config,
       deductCredits,
       refundCredits,

package/src/presentation/hooks/index.ts

@@ -10,6 +10,7 @@ export {
   useDualImageGeneration,
   useImagePicker,
   useImageGenerationExecutor,
+  useAudioGenerationExecutor,
   createGenerationError,
   getAlertMessage,
   parseError,
@@ -39,6 +40,9 @@ export type {
   AIImageResult,
   ImageGenerationExecutorConfig,
   ImageGenerationExecutorReturn,
+  AudioGenerationInput,
+  AudioGenerationExecutorConfig,
+  AudioGenerationExecutorReturn,
 } from "./generation";
 
 export { useGeneration } from "./use-generation";