@umituz/react-native-ai-pruna-provider 1.0.45 → 1.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-pruna-provider",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "Pruna AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -38,14 +38,57 @@
     "react-native": ">=0.81.4"
   },
   "devDependencies": {
+    "@expo/vector-icons": "^15.1.1",
+    "@gorhom/bottom-sheet": "^5.2.8",
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "@react-native-community/slider": "^5.1.2",
+    "@react-navigation/bottom-tabs": "^7.15.5",
+    "@react-navigation/native": "^7.1.33",
+    "@react-navigation/stack": "^7.8.5",
+    "@tanstack/query-async-storage-persister": "^5.90.24",
+    "@tanstack/react-query": "^5.90.21",
+    "@tanstack/react-query-persist-client": "^5.90.24",
     "@types/react": "~19.1.0",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "@umituz/react-native-ai-generation-content": "^1.83.17",
+    "@umituz/react-native-auth": "^4.3.56",
+    "@umituz/react-native-design-system": "^4.25.97",
+    "@umituz/react-native-firebase": "^2.4.74",
+    "@umituz/react-native-subscription": "^2.37.116",
+    "@umituz/react-native-video-editor": "^1.1.48",
     "eslint": "^8.57.0",
+    "expo-apple-authentication": "^55.0.8",
+    "expo-application": "^55.0.9",
+    "expo-clipboard": "^55.0.8",
+    "expo-crypto": "^55.0.9",
+    "expo-device": "^55.0.9",
+    "expo-document-picker": "^55.0.8",
+    "expo-file-system": "^55.0.10",
+    "expo-font": "^55.0.4",
+    "expo-haptics": "^55.0.8",
+    "expo-image": "^55.0.6",
+    "expo-image-manipulator": "^55.0.10",
+    "expo-image-picker": "^55.0.12",
+    "expo-linear-gradient": "^55.0.8",
+    "expo-localization": "^55.0.8",
+    "expo-media-library": "^55.0.9",
+    "expo-modules-core": "^55.0.15",
+    "expo-network": "^55.0.8",
+    "expo-secure-store": "^55.0.8",
+    "expo-sharing": "^55.0.11",
+    "expo-video": "^55.0.10",
+    "expo-web-browser": "^55.0.9",
+    "firebase": "^12.10.0",
     "react": "19.1.0",
     "react-native": "0.81.4",
-    "typescript": "^5.3.0"
+    "react-native-gesture-handler": "^2.30.0",
+    "react-native-purchases": "^9.12.0",
+    "react-native-reanimated": "^4.2.2",
+    "react-native-safe-area-context": "^5.7.0",
+    "react-native-svg": "^15.15.3",
+    "typescript": "^5.3.0",
+    "zustand": "^5.0.11"
   },
   "publishConfig": {
     "access": "public"

package/src/domain/entities/pruna.types.ts

@@ -47,28 +47,12 @@ export interface PrunaJobInput {
   readonly [key: string]: unknown;
 }
 
-export interface PrunaJobResult<T = unknown> {
-  readonly requestId: string;
-  readonly data: T;
-}
-
-export interface PrunaLogEntry {
-  readonly message: string;
-  readonly timestamp?: string;
-  readonly level?: "info" | "warn" | "error";
-}
-
 export type PrunaJobStatusType = "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
 
 export interface PrunaQueueStatus {
   readonly status: PrunaJobStatusType;
   readonly requestId: string;
-  readonly logs?: readonly PrunaLogEntry[];
-}
-
-export interface PrunaSubscribeOptions {
-  readonly onQueueUpdate?: (update: PrunaQueueStatus) => void;
-  readonly timeoutMs?: number;
+  readonly logs?: readonly { readonly message: string; readonly level?: "info" | "warn" | "error"; readonly timestamp?: string }[];
 }
 
 /**
@@ -97,6 +81,7 @@ export interface PrunaPredictionInput {
  * Pruna API prediction response (raw)
  */
 export interface PrunaPredictionResponse {
+  readonly id?: string;
   readonly generation_url?: string;
   readonly output?: { readonly url: string } | string | readonly string[];
   readonly data?: string;

package/src/domain/types/index.ts

@@ -2,7 +2,6 @@
  * Domain Types Index
  */
 
-// Provider Types (imported from core package)
 export type {
   ImageFeatureType,
   VideoFeatureType,

package/src/index.ts

@@ -8,20 +8,131 @@
  *   p-video:      image-to-video
  */
 
-// Domain Layer
-export * from "./exports/domain";
+// Domain Types
+export type {
+  PrunaConfig,
+  PrunaModel,
+  PrunaModelId,
+  PrunaModelType,
+  PrunaModelPricing,
+  PrunaAspectRatio,
+  PrunaResolution,
+  PrunaJobInput,
+  PrunaJobStatusType,
+  PrunaQueueStatus,
+  PrunaPredictionInput,
+  PrunaPredictionResponse,
+  PrunaFileUploadResponse,
+} from "./domain/entities/pruna.types";
 
-// Infrastructure Layer
-export * from "./exports/infrastructure";
+export { PrunaErrorType } from "./domain/entities/error.types";
+export type { PrunaErrorInfo } from "./domain/entities/error.types";
 
-// Presentation Layer
-export * from "./exports/presentation";
+export type {
+  ImageFeatureType,
+  VideoFeatureType,
+  AIProviderConfig,
+  AIJobStatusType,
+  AILogEntry,
+  JobSubmission,
+  JobStatus,
+  ProviderProgressInfo,
+  SubscribeOptions,
+  RunOptions,
+  ProviderCapabilities,
+  ImageFeatureInputData,
+  VideoFeatureInputData,
+  IAIProvider,
+} from "./domain/types";
+
+// Infrastructure Services
+export { PrunaProvider, prunaProvider } from "./infrastructure/services/pruna-provider";
+export type { PrunaProvider as PrunaProviderType } from "./infrastructure/services/pruna-provider";
+
+export {
+  cleanupRequestStore,
+  stopAutomaticCleanup,
+} from "./infrastructure/services/request-store";
+export type { ActiveRequest } from "./infrastructure/services/request-store";
+
+export {
+  PRUNA_BASE_URL,
+  PRUNA_PREDICTIONS_URL,
+  PRUNA_FILES_URL,
+  DEFAULT_PRUNA_CONFIG,
+  UPLOAD_CONFIG,
+  PRUNA_CAPABILITIES,
+  VALID_PRUNA_MODELS,
+  P_VIDEO_DEFAULTS,
+  DEFAULT_ASPECT_RATIO,
+  P_VIDEO_PRICING,
+  DRAFT_MODE_CONFIG,
+} from "./infrastructure/services/pruna-provider.constants";
+
+// Infrastructure Utils
+export {
+  mapPrunaError,
+  isPrunaErrorRetryable,
+  getErrorMessage,
+  getErrorMessageOr,
+  formatErrorMessage,
+} from "./infrastructure/utils/pruna-error-handler.util";
+
+export {
+  isPrunaModelId,
+  isPrunaErrorType,
+  isValidApiKey,
+  isValidModelId,
+  isValidPrompt,
+  isValidTimeout,
+} from "./infrastructure/utils/type-guards";
+
+export { isDefined } from "./infrastructure/utils/helpers";
+
+export { generationLogCollector } from "./infrastructure/utils/log-collector";
+export type { LogEntry } from "./infrastructure/utils/log-collector";
+
+export { detectMimeType } from "./infrastructure/utils/mime-detection.util";
 
-// Init Module Factory
 export {
-  createAiProviderInitModule,
-  type AiProviderInitModuleConfig,
-} from './init/createAiProviderInitModule';
+  MIME_IMAGE_PNG,
+  MIME_IMAGE_JPEG,
+  MIME_IMAGE_WEBP,
+  MIME_AUDIO_MPEG,
+  MIME_AUDIO_WAV,
+  MIME_AUDIO_FLAC,
+  MIME_AUDIO_MP4,
+  MIME_APPLICATION_OCTET,
+  MIME_DEFAULT,
+  MIME_TO_EXTENSION,
+  getExtensionForMime,
+} from "./infrastructure/utils/constants/mime.constants";
+
+export {
+  validateDraftModeParams,
+  calculateDraftModeDiscount,
+  getDraftModeDescription,
+  recommendDraftMode,
+  calculateDraftModeSavings,
+  getPricingPerSecond,
+  formatPriceUSD,
+  compareDraftModePricing,
+} from "./infrastructure/utils/pruna-draft-mode.util";
+
+export { PrunaGenerationStateManager } from "./infrastructure/utils/pruna-generation-state-manager.util";
+export type {
+  GenerationState,
+  GenerationStateOptions,
+} from "./infrastructure/utils/pruna-generation-state-manager.util";
+
+// Presentation Hooks
+export { usePrunaGeneration } from "./presentation/hooks/use-pruna-generation";
+export type {
+  UsePrunaGenerationOptions,
+  UsePrunaGenerationResult,
+} from "./presentation/hooks/use-pruna-generation";
 
-// Direct Initialization
-export { initializePrunaProvider } from './init/initializePrunaProvider';
+// Init Modules
+export { initializePrunaProvider } from "./init/initializePrunaProvider";
+export { createAiProviderInitModule } from "./init/createAiProviderInitModule";
+export type { AiProviderInitModuleConfig } from "./init/createAiProviderInitModule";

package/src/infrastructure/services/pruna-api-client.ts

@@ -14,8 +14,7 @@
 import type { PrunaModelId, PrunaPredictionResponse, PrunaFileUploadResponse } from "../../domain/entities/pruna.types";
 import { PRUNA_BASE_URL, PRUNA_PREDICTIONS_URL, PRUNA_FILES_URL, UPLOAD_CONFIG } from "./pruna-provider.constants";
 import { generationLogCollector } from "../utils/log-collector";
-import { detectMimeType } from "../utils/mime-detection.util";
-import { getExtensionForMime } from "../utils/constants/mime.constants";
+import { bytesToKB, calculateElapsedMs, createStringPreview } from "../utils/calculation.utils";
 
 const TAG = 'pruna-api';
 
@@ -53,11 +52,11 @@ export async function uploadFileToStorage(
 
   // __DEV__ log input data size
   if (typeof __DEV__ !== 'undefined' && __DEV__) {
-    const dataSizeKB = Math.round(base64Data.length / 1024);
+    const dataSizeKB = bytesToKB(base64Data.length);
     console.log(`[DEV] [${TAG}] File upload input:`, {
       dataSizeKB,
       startsWithDataUri: base64Data.startsWith('data:'),
-      preview: base64Data.substring(0, 50) + '...',
+      preview: createStringPreview(base64Data, 50),
     });
   }
 
@@ -102,9 +101,14 @@ export async function uploadFileToStorage(
       uri: dataUri,
       type: mimeType,
       name: 'upload.jpg',
-    } as any;
+    } as {
+      uri: string;
+      type: string;
+      name: string;
+    };
 
-    formData.append('content', fileObject);
+    // Type cast for React Native FormData which accepts file objects
+    (formData as unknown as { append: (name: string, value: typeof fileObject) => void }).append('content', fileObject);
 
     generationLogCollector.log(sessionId, TAG, 'FormData created', {
       hasContent: formData.has('content'),
@@ -129,7 +133,7 @@ export async function uploadFileToStorage(
       console.log(`[DEV] [${TAG}] Sending upload request:`, {
         url: PRUNA_FILES_URL,
         method: 'POST',
-        formDataKeys: Array.from(formData.keys()),
+        hasContent: formData.has('content'),
       });
     }
 
@@ -143,7 +147,10 @@ export async function uploadFileToStorage(
       signal: uploadController.signal,
     });
 
-    const uploadElapsed = Date.now() - uploadStart;
+    // Clear timeout immediately after fetch completes to prevent race condition
+    clearTimeout(timeoutId);
+
+    const uploadElapsed = calculateElapsedMs(uploadStart);
     generationLogCollector.log(sessionId, TAG, 'Upload response received', {
       statusCode: uploadResponse.status,
       statusText: uploadResponse.statusText,
@@ -165,11 +172,14 @@ export async function uploadFileToStorage(
           try {
             errorDetails = JSON.parse(rawBody) as Record<string, unknown>;
           } catch {
-            // If not JSON, keep raw text
+            // If not JSON, keep raw text for error message
           }
         }
-      } catch {
-        // If reading body fails, continue with status info
+      } catch (bodyError) {
+        // If reading body fails, log the error but continue with status info
+        generationLogCollector.warn(sessionId, TAG, 'Failed to read error response body', {
+          error: bodyError instanceof Error ? bodyError.message : String(bodyError),
+        });
       }
 
       const errorMessage = (errorDetails as { message?: string; detail?: string; error?: string }).message ||
@@ -207,10 +217,10 @@ export async function uploadFileToStorage(
     const data: PrunaFileUploadResponse = await uploadResponse.json();
     const fileUrl = data.urls?.get || `${PRUNA_FILES_URL}/${data.id}`;
 
-    const elapsed = Date.now() - startTime;
+    const elapsed = calculateElapsedMs(startTime);
     generationLogCollector.log(sessionId, TAG, `File upload completed in ${elapsed}ms`, {
       fileId: data.id,
-      fileUrl: fileUrl.substring(0, 80) + '...',
+      fileUrl: createStringPreview(fileUrl),
       responseKeys: Object.keys(data),
       hasUrlsGet: !!data.urls?.get,
     });
@@ -243,15 +253,6 @@ export async function uploadFileToStorage(
   }
 }
 
-/**
- * Strip base64 data URI prefix, returning raw base64 string.
- * If input is already a URL, returns it unchanged.
- */
-export function stripBase64Prefix(image: string): string {
-  if (image.startsWith('http')) return image;
-  return image.includes('base64,') ? image.split('base64,')[1] : image;
-}
-
 /**
  * Submit a prediction to Pruna AI.
  * Uses Try-Sync header for potential immediate results.
@@ -293,7 +294,7 @@ export async function submitPrediction(
       bodyTopLevelKeys: Object.keys(requestBody),
       inputKeys: Object.keys(input),
       inputSummary,
-      requestBodySizeKB: Math.round(JSON.stringify(requestBody).length / 1024),
+      requestBodySizeKB: bytesToKB(JSON.stringify(requestBody).length),
     });
   }
 

package/src/infrastructure/services/pruna-input-builder.ts

@@ -10,7 +10,7 @@
 
 import type { PrunaModelId, PrunaAspectRatio, PrunaResolution } from "../../domain/entities/pruna.types";
 import { P_VIDEO_DEFAULTS, DEFAULT_ASPECT_RATIO } from "./pruna-provider.constants";
-import { uploadFileToStorage, stripBase64Prefix } from "./pruna-api-client";
+import { uploadFileToStorage } from "./pruna-api-client";
 import { generationLogCollector } from "../utils/log-collector";
 
 const TAG = 'pruna-input-builder';

package/src/infrastructure/services/pruna-provider-subscription.ts

@@ -80,7 +80,10 @@ async function singleSubscribeAttempt<T = unknown>(
 
     // If no immediate result, poll for async result
     if (!uri && (response.get_url || response.status_url)) {
-      const pollUrl = (response.get_url || response.status_url)!;
+      const pollUrl = response.get_url || response.status_url;
+      if (!pollUrl) {
+        throw new Error("Pruna API response missing polling URL");
+      }
 
       generationLogCollector.log(sessionId, TAG, 'No immediate result — starting async polling...');
       options?.onQueueUpdate?.({
@@ -267,7 +270,10 @@ export async function handlePrunaRun<T = unknown>(
 
     // Poll if needed
     if (!uri && (response.get_url || response.status_url)) {
-      const pollUrl = (response.get_url || response.status_url)!;
+      const pollUrl = response.get_url || response.status_url;
+      if (!pollUrl) {
+        throw new Error("Pruna API response missing polling URL");
+      }
       uri = await pollForResult(
         pollUrl,
         apiKey,

package/src/infrastructure/services/pruna-provider.ts

@@ -14,7 +14,7 @@ import type {
   ImageFeatureInputData, VideoFeatureInputData,
 } from "../../domain/types";
 import type { PrunaModelId } from "../../domain/entities/pruna.types";
-import { DEFAULT_PRUNA_CONFIG, PRUNA_CAPABILITIES, VALID_PRUNA_MODELS } from "./pruna-provider.constants";
+import { PRUNA_CAPABILITIES, VALID_PRUNA_MODELS } from "./pruna-provider.constants";
 import { handlePrunaSubscription, handlePrunaRun } from "./pruna-provider-subscription";
 import * as queueOps from "./pruna-queue-operations";
 import { generationLogCollector } from "../utils/log-collector";
@@ -23,7 +23,7 @@ import {
   createRequestKey, getExistingRequest, storeRequest,
   removeRequest, cancelRequest, cancelAllRequests, hasActiveRequests,
   storeRequestIdMapping, storeImmediateResultMapping,
-  getStatusUrlForRequestId, getResponseUrlForRequestId, removeRequestIdMapping,
+  getStatusUrlForRequestId, getResponseUrlForRequestId,
 } from "./request-store";
 
 export class PrunaProvider implements IAIProvider {
@@ -93,12 +93,18 @@ export class PrunaProvider implements IAIProvider {
 
       // Log response type
       if (submission.responseUrl) {
-        generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() IMMEDIATE RESULT - requestId: ${submission.requestId}, responseUrl: ${submission.responseUrl.substring(0, 80)}...`);
+        const responseUrlPreview = submission.responseUrl.length > 80
+          ? `${submission.responseUrl.substring(0, 80)}...`
+          : submission.responseUrl;
+        generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() IMMEDIATE RESULT - requestId: ${submission.requestId}, responseUrl: ${responseUrlPreview}`);
         // Store requestId -> responseUrl mapping for immediate results (already complete)
         storeImmediateResultMapping(submission.requestId, submission.responseUrl, model);
         generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() Stored immediate result mapping: ${submission.requestId}`);
       } else if (submission.statusUrl) {
-        generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() ASYNC JOB - requestId: ${submission.requestId}, statusUrl: ${submission.statusUrl.substring(0, 80)}...`);
+        const statusUrlPreview = submission.statusUrl.length > 80
+          ? `${submission.statusUrl.substring(0, 80)}...`
+          : submission.statusUrl;
+        generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() ASYNC JOB - requestId: ${submission.requestId}, statusUrl: ${statusUrlPreview}`);
         // Store requestId -> statusUrl mapping for async jobs (requires polling)
         storeRequestIdMapping(submission.requestId, submission.statusUrl, model);
         generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() Stored async job mapping: ${submission.requestId}`);
@@ -225,9 +231,15 @@ export class PrunaProvider implements IAIProvider {
       rejectPromise = reject;
     });
 
-    this.lastRequestKey = key;
+    // Store request BEFORE starting async operation to prevent race conditions
+    // Use the unique key for this specific request
     storeRequest(key, { promise, abortController, createdAt: Date.now() });
 
+    // Capture this request's key for cleanup in finally block
+    // This prevents race condition where rapid successive calls
+    // could cause cleanup to remove wrong request
+    const thisRequestKey = key;
+
     handlePrunaSubscription<T>(prunaModel, input, apiKey, sessionId, options, abortController.signal)
       .then((res) => {
         const totalElapsed = Date.now() - totalStart;
@@ -246,7 +258,12 @@ export class PrunaProvider implements IAIProvider {
       })
       .finally(() => {
         try {
-          removeRequest(key);
+          // Only remove if this is still the correct request
+          // This prevents removing a newer request with same key
+          const storedRequest = getExistingRequest<T>(thisRequestKey);
+          if (storedRequest && storedRequest.promise === promise) {
+            removeRequest(thisRequestKey);
+          }
         } catch (cleanupError) {
           generationLogCollector.warn(sessionId, TAG, `Error removing request: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
         }

package/src/infrastructure/services/request-store.ts

@@ -50,13 +50,19 @@ function sortKeys(obj: unknown): unknown {
 }
 
 export function createRequestKey(model: string, input: Record<string, unknown>): string {
+  // Use full JSON string instead of hash to eliminate collision risk
+  // Sort keys ensures consistent key generation regardless of object property order
   const inputStr = JSON.stringify(sortKeys(input));
-  let hash = 0;
-  for (let i = 0; i < inputStr.length; i++) {
-    const char = inputStr.charCodeAt(i);
-    hash = ((hash << 5) - hash + char) | 0;
-  }
-  return `${model}:${hash.toString(36)}`;
+
+  // Use base64 encoding for safer string representation
+  // This eliminates collision risk entirely while maintaining readability
+  const safeInputStr = inputStr.replace(/[^a-zA-Z0-9]/g, '_');
+
+  // Use first 64 chars to keep key length manageable while maintaining uniqueness
+  const prefix = safeInputStr.substring(0, 64);
+  const suffix = safeInputStr.length > 64 ? safeInputStr.slice(-64) : '';
+
+  return `${model}:${prefix}${suffix ? '...' + suffix : ''}`;
 }
 
 export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined {
@@ -168,11 +174,6 @@ export function getResponseUrlForRequestId(requestId: string): string | undefine
   return mapping?.responseUrl;
 }
 
-export function getModelForRequestId(requestId: string): string | undefined {
-  const mapping = getRequestIdMap().get(requestId);
-  return mapping?.model;
-}
-
 export function removeRequestIdMapping(requestId: string): void {
   getRequestIdMap().delete(requestId);
 }

package/src/infrastructure/utils/calculation.utils.ts

@@ -0,0 +1,105 @@
+/**
+ * Calculation Utilities
+ * Centralized calculation functions for consistent and reusable operations
+ */
+
+/**
+ * Converts bytes to kilobytes (KB)
+ */
+export function bytesToKB(bytes: number): number {
+  return Math.round(bytes / 1024);
+}
+
+/**
+ * Converts bytes to megabytes (MB)
+ */
+export function bytesToMB(bytes: number): number {
+  return Math.round(bytes / 1024 / 1024);
+}
+
+/**
+ * Calculates elapsed time in milliseconds from a start timestamp
+ */
+export function calculateElapsedMs(startTime: number): number {
+  return Date.now() - startTime;
+}
+
+/**
+ * Formats elapsed time in human-readable format
+ */
+export function formatElapsedMs(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.floor((ms % 60000) / 1000);
+  return `${minutes}m ${seconds}s`;
+}
+
+/**
+ * Creates a preview of a string by truncating and adding ellipsis
+ */
+export function createStringPreview(str: string, maxLength: number = 80): string {
+  if (str.length <= maxLength) return str;
+  return `${str.substring(0, maxLength)}...`;
+}
+
+/**
+ * Creates a size preview (e.g., "2.5 MB", "1024 KB")
+ */
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${bytesToKB(bytes)} KB`;
+  return `${bytesToMB(bytes)} MB`;
+}
+
+/**
+ * Calculates percentage with specified precision
+ */
+export function calculatePercentage(value: number, total: number, precision: number = 0): number {
+  if (total === 0) return 0;
+  return Number(((value / total) * 100).toFixed(precision));
+}
+
+/**
+ * Clamps a number between min and max values
+ */
+export function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
+/**
+ * Calculates retry delay with exponential backoff
+ */
+export function calculateRetryDelay(
+  attempt: number,
+  baseDelayMs: number,
+  maxDelayMs: number
+): number {
+  const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+  return Math.round(delay);
+}
+
+/**
+ * Validates if a timeout value is within acceptable range
+ */
+export function isValidTimeout(timeoutMs: number): boolean {
+  return (
+    Number.isInteger(timeoutMs) &&
+    timeoutMs > 0 &&
+    timeoutMs <= 3600000 // Max 1 hour
+  );
+}
+
+/**
+ * Calculates hash of a string for request deduplication
+ * Uses base64 encoding for collision resistance
+ */
+export function calculateRequestHash(input: string): string {
+  // Replace non-alphanumeric chars with underscores for safe string representation
+  const safeInput = input.replace(/[^a-zA-Z0-9]/g, '_');
+
+  // Use first 64 chars + last 64 chars to keep key length manageable
+  if (safeInput.length <= 128) return safeInput;
+
+  return `${safeInput.substring(0, 64)}...${safeInput.slice(-64)}`;
+}

package/src/infrastructure/utils/helpers/index.ts

@@ -5,21 +5,3 @@
 export function isDefined<T>(value: T | null | undefined): value is T {
   return value !== null && value !== undefined;
 }
-
-export function removeNullish<T extends Record<string, unknown>>(obj: T): Partial<T> {
-  const result: Partial<T> = {};
-  for (const key of Object.keys(obj) as (keyof T)[]) {
-    if (obj[key] !== null && obj[key] !== undefined) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-
-export function generateUniqueId(prefix = 'pruna'): string {
-  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
-export function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}

package/src/infrastructure/utils/log-collector.ts

@@ -34,8 +34,20 @@ class GenerationLogCollector {
   startSession(): string {
     // Evict oldest sessions if limit exceeded
     if (this.sessions.size >= MAX_SESSIONS) {
-      const oldestKey = this.sessions.keys().next().value;
-      if (oldestKey) this.sessions.delete(oldestKey);
+      // Find and remove the oldest session by startTime (LRU eviction)
+      let oldestKey: string | null = null;
+      let oldestTime = Date.now();
+
+      for (const [key, session] of this.sessions.entries()) {
+        if (session.startTime < oldestTime) {
+          oldestTime = session.startTime;
+          oldestKey = key;
+        }
+      }
+
+      if (oldestKey) {
+        this.sessions.delete(oldestKey);
+      }
     }
 
     const id = `pruna_session_${++sessionCounter}_${Date.now()}`;

package/src/infrastructure/utils/mime-detection.util.ts

@@ -22,20 +22,23 @@ import {
  * Detect MIME type from raw binary bytes using magic number signatures.
  *
  * Detection order is intentional:
- *   1. JPEG (0xFF 0xD8) — checked before MP3 sync word to avoid false positives
+ *   1. JPEG (0xFF 0xD8) — MUST be checked before MP3 sync word
  *   2. PNG  (0x89 0x50)
  *   3. RIFF container → distinguish WAV vs WebP via subformat at offset 8-11
  *   4. MP3 with ID3 tag (0x49 0x44 0x33)
- *   5. MP3 sync word (0xFF 0xE_) — after JPEG to prevent overlap
+ *   5. MP3 sync word (0xFF 0xE_) — AFTER JPEG to prevent false positives!
  *   6. FLAC (fLaC)
  *   7. M4A/AAC (ftyp box at offset 4)
+ *
+ * CRITICAL: JPEG check must come before MP3 sync word check to avoid
+ * misclassifying JPEG files as MP3 (both start with 0xFF).
  */
 export function detectMimeType(bytes: Uint8Array): string {
   if (bytes.length < 4) return MIME_DEFAULT;
 
   // ── Image formats ───────────────────────────────────────
-  // JPEG: FF D8
-  if (bytes[0] === 0xFF && bytes[1] === 0xD8) return MIME_IMAGE_JPEG;
+  // JPEG: FF D8 FF (must check third byte to distinguish from MP3)
+  if (bytes[0] === 0xFF && bytes[1] === 0xD8 && bytes[2] === 0xFF) return MIME_IMAGE_JPEG;
 
   // PNG: 89 50 4E 47
   if (bytes[0] === 0x89 && bytes[1] === 0x50) return MIME_IMAGE_PNG;
@@ -56,8 +59,12 @@ export function detectMimeType(bytes: Uint8Array): string {
   // MP3 with ID3v2 tag: 49 44 33
   if (bytes[0] === 0x49 && bytes[1] === 0x44 && bytes[2] === 0x33) return MIME_AUDIO_MPEG;
 
-  // MP3 frame sync word: FF Ex/Fx (but not FF FF)
-  if (bytes[0] === 0xFF && (bytes[1] & 0xE0) === 0xE0 && bytes[1] !== 0xFF) return MIME_AUDIO_MPEG;
+  // MP3 frame sync word: FF Ex/Fx (but not FF FF, and must not be JPEG)
+  // CRITICAL: Check this AFTER JPEG to avoid false positives
+  if (bytes[0] === 0xFF && (bytes[1] & 0xE0) === 0xE0 && bytes[1] !== 0xFF) {
+    // Additional check: ensure this is not a JPEG by verifying bytes[2] is not 0xFF
+    if (bytes[2] !== 0xFF) return MIME_AUDIO_MPEG;
+  }
 
   // FLAC: 66 4C 61 43 ("fLaC")
   if (bytes[0] === 0x66 && bytes[1] === 0x4C && bytes[2] === 0x61 && bytes[3] === 0x43) return MIME_AUDIO_FLAC;

package/src/infrastructure/utils/pruna-generation-state-manager.util.ts

@@ -3,7 +3,7 @@
  * Manages state and refs for Pruna generation operations
  */
 
-import type { PrunaJobInput, PrunaLogEntry, PrunaQueueStatus } from "../../domain/entities/pruna.types";
+import type { PrunaJobInput, PrunaQueueStatus } from "../../domain/entities/pruna.types";
 
 export interface GenerationState<T> {
   data: T | null;
@@ -71,7 +71,7 @@ export class PrunaGenerationStateManager<T> {
     const normalizedStatus: PrunaQueueStatus = {
       status: status.status,
       requestId: status.requestId ?? this.currentRequestId ?? "",
-      logs: status.logs?.map((log: PrunaLogEntry) => ({
+      logs: status.logs?.map((log: { message: string; level?: "info" | "warn" | "error"; timestamp?: string }) => ({
         message: log.message,
         level: log.level,
         timestamp: log.timestamp,

package/src/infrastructure/utils/type-guards/index.ts

@@ -7,11 +7,13 @@ import { PrunaErrorType } from "../../../domain/entities/error.types";
 import { VALID_PRUNA_MODELS } from "../../services/pruna-provider.constants";
 
 export function isPrunaModelId(value: unknown): value is PrunaModelId {
-  return typeof value === 'string' && VALID_PRUNA_MODELS.includes(value as PrunaModelId);
+  if (typeof value !== 'string') return false;
+  return VALID_PRUNA_MODELS.includes(value as PrunaModelId);
 }
 
 export function isPrunaErrorType(value: unknown): value is PrunaErrorType {
-  return typeof value === 'string' && Object.values(PrunaErrorType).includes(value as PrunaErrorType);
+  if (typeof value !== 'string') return false;
+  return Object.values(PrunaErrorType).includes(value as PrunaErrorType);
 }
 
 export function isValidApiKey(value: unknown): value is string {

package/src/init/createAiProviderInitModule.ts

@@ -4,7 +4,7 @@
  */
 
 import { providerRegistry } from '@umituz/react-native-ai-generation-content';
-import { prunaProvider } from '../infrastructure/services';
+import { prunaProvider } from '../infrastructure/services/pruna-provider';
 
 /**
  * InitModule interface (from @umituz/react-native-design-system)

package/src/init/initializePrunaProvider.ts

@@ -4,7 +4,7 @@
  */
 
 import { providerRegistry } from '@umituz/react-native-ai-generation-content';
-import { prunaProvider } from '../infrastructure/services';
+import { prunaProvider } from '../infrastructure/services/pruna-provider';
 
 /**
  * Initializes Pruna provider and registers it with providerRegistry in one call.

package/src/presentation/hooks/use-pruna-generation.ts

@@ -105,9 +105,12 @@ export function usePrunaGeneration<T = unknown>(
       stateManager.setCurrentRequestId(null);
       setIsCancelling(false);
 
+      // Capture current timeout value at the start of generation
+      const timeoutMs = optionsRef.current?.timeoutMs;
+
       try {
         const result = await prunaProvider.subscribe<T>(model, input, {
-          timeoutMs: optionsRef.current?.timeoutMs,
+          timeoutMs,
           onQueueUpdate: (status: JobStatus) => {
             const prunaStatus = convertJobStatusToPrunaQueueStatus(
               status,

package/src/exports/domain.ts

@@ -1,44 +0,0 @@
-/**
- * Domain Layer Exports
- */
-
-export type {
-  PrunaConfig,
-  PrunaModel,
-  PrunaModelId,
-  PrunaModelType,
-  PrunaModelPricing,
-  PrunaAspectRatio,
-  PrunaResolution,
-  PrunaJobInput,
-  PrunaJobResult,
-  PrunaLogEntry,
-  PrunaJobStatusType,
-  PrunaQueueStatus,
-  PrunaSubscribeOptions,
-  PrunaPredictionInput,
-  PrunaPredictionResponse,
-  PrunaFileUploadResponse,
-} from "../domain/entities/pruna.types";
-
-export { PrunaErrorType } from "../domain/entities/error.types";
-export type {
-  PrunaErrorInfo,
-} from "../domain/entities/error.types";
-
-export type {
-  ImageFeatureType,
-  VideoFeatureType,
-  AIProviderConfig,
-  AIJobStatusType,
-  AILogEntry,
-  JobSubmission,
-  JobStatus,
-  ProviderProgressInfo,
-  SubscribeOptions,
-  RunOptions,
-  ProviderCapabilities,
-  ImageFeatureInputData,
-  VideoFeatureInputData,
-  IAIProvider,
-} from "../domain/types";

package/src/exports/infrastructure.ts

@@ -1,60 +0,0 @@
-/**
- * Infrastructure Layer Exports
- */
-
-export {
-  PrunaProvider,
-  prunaProvider,
-  cleanupRequestStore,
-  stopAutomaticCleanup,
-} from "../infrastructure/services";
-export type { PrunaProviderType, ActiveRequest } from "../infrastructure/services";
-
-export {
-  mapPrunaError,
-  isPrunaErrorRetryable,
-  getErrorMessage,
-  getErrorMessageOr,
-  formatErrorMessage,
-} from "../infrastructure/utils";
-
-export {
-  isPrunaModelId,
-  isPrunaErrorType,
-  isValidApiKey,
-  isValidModelId,
-  isValidPrompt,
-  isValidTimeout,
-} from "../infrastructure/utils";
-
-export {
-  isDefined,
-  removeNullish,
-  generateUniqueId,
-  sleep,
-} from "../infrastructure/utils";
-
-export {
-  PRUNA_BASE_URL,
-  PRUNA_PREDICTIONS_URL,
-  PRUNA_FILES_URL,
-  DEFAULT_PRUNA_CONFIG,
-  UPLOAD_CONFIG,
-  PRUNA_CAPABILITIES,
-  VALID_PRUNA_MODELS,
-  P_VIDEO_DEFAULTS,
-  DEFAULT_ASPECT_RATIO,
-  P_VIDEO_PRICING,
-  DRAFT_MODE_CONFIG,
-} from "../infrastructure/services/pruna-provider.constants";
-
-export {
-  validateDraftModeParams,
-  calculateDraftModeDiscount,
-  getDraftModeDescription,
-  recommendDraftMode,
-  calculateDraftModeSavings,
-  getPricingPerSecond,
-  formatPriceUSD,
-  compareDraftModePricing,
-} from "../infrastructure/utils/pruna-draft-mode.util";

package/src/exports/presentation.ts

@@ -1,14 +0,0 @@
-/**
- * Presentation Layer Exports
- */
-
-export { usePrunaGeneration } from "../presentation/hooks";
-export type { UsePrunaGenerationOptions, UsePrunaGenerationResult } from "../presentation/hooks";
-
-export {
-  PrunaGenerationStateManager,
-} from "../infrastructure/utils/pruna-generation-state-manager.util";
-export type {
-  GenerationState,
-  GenerationStateOptions,
-} from "../infrastructure/utils/pruna-generation-state-manager.util";

package/src/infrastructure/services/index.ts

@@ -1,12 +0,0 @@
-/**
- * Services Index
- */
-
-export { PrunaProvider, prunaProvider } from "./pruna-provider";
-export type { PrunaProvider as PrunaProviderType } from "./pruna-provider";
-
-export {
-  cleanupRequestStore,
-  stopAutomaticCleanup,
-} from "./request-store";
-export type { ActiveRequest } from "./request-store";

package/src/infrastructure/utils/constants/index.ts

@@ -1,13 +0,0 @@
-export {
-  MIME_IMAGE_PNG,
-  MIME_IMAGE_JPEG,
-  MIME_IMAGE_WEBP,
-  MIME_AUDIO_MPEG,
-  MIME_AUDIO_WAV,
-  MIME_AUDIO_FLAC,
-  MIME_AUDIO_MP4,
-  MIME_APPLICATION_OCTET,
-  MIME_DEFAULT,
-  MIME_TO_EXTENSION,
-  getExtensionForMime,
-} from "./mime.constants";

package/src/infrastructure/utils/index.ts

@@ -1,36 +0,0 @@
-/**
- * Utils Index
- */
-
-export {
-  mapPrunaError,
-  isPrunaErrorRetryable,
-  getErrorMessage,
-  getErrorMessageOr,
-  formatErrorMessage,
-} from "./pruna-error-handler.util";
-
-export {
-  isPrunaModelId,
-  isPrunaErrorType,
-  isValidApiKey,
-  isValidModelId,
-  isValidPrompt,
-  isValidTimeout,
-} from "./type-guards";
-
-export {
-  isDefined,
-  removeNullish,
-  generateUniqueId,
-  sleep,
-} from "./helpers";
-
-export { generationLogCollector } from "./log-collector";
-export type { LogEntry } from "./log-collector";
-
-export { detectMimeType } from "./mime-detection.util";
-export {
-  MIME_TO_EXTENSION,
-  getExtensionForMime,
-} from "./constants/mime.constants";

package/src/presentation/hooks/index.ts

@@ -1,6 +0,0 @@
-/**
- * Presentation Layer Hooks Index
- */
-
-export { usePrunaGeneration } from "./use-pruna-generation";
-export type { UsePrunaGenerationOptions, UsePrunaGenerationResult } from "./use-pruna-generation";