@umituz/react-native-ai-gemini-provider 1.11.0 → 1.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "description": "Google Gemini AI provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,10 +32,12 @@
   "peerDependencies": {
     "react": ">=18.2.0",
     "react-native": ">=0.74.0",
-    "@google/generative-ai": ">=0.21.0"
+    "@google/generative-ai": ">=0.21.0",
+    "@umituz/react-native-ai-generation-content": ">=1.16.0"
   },
   "devDependencies": {
     "@google/generative-ai": "^0.21.0",
+    "@umituz/react-native-ai-generation-content": "latest",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "eslint": "^8.57.0",

package/src/domains/index.ts

@@ -3,3 +3,4 @@
  */
 
 export * from "./upscaling";
+export * from "./photo-restoration";

package/src/domains/photo-restoration/domain/index.ts

@@ -0,0 +1 @@
+export * from "./types";

package/src/domains/photo-restoration/domain/types.ts

@@ -0,0 +1,23 @@
+/**
+ * Photo Restore Domain Types
+ */
+
+export interface PhotoRestoreOptions {
+  fixScratches?: boolean;
+  enhanceFaces?: boolean;
+  colorize?: boolean;
+}
+
+export interface PhotoRestoreInput {
+  base64: string;
+  mimeType: string;
+  options?: PhotoRestoreOptions;
+}
+
+export interface PhotoRestoreServiceResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  mimeType?: string;
+  error?: string;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Photo Restoration Domain - Public API
+ *
+ * Exports GeminiPhotoRestoreProvider for use with content package registry
+ */
+
+// Provider (implements IPhotoRestoreProvider)
+export {
+  geminiPhotoRestoreProvider,
+  type IPhotoRestoreProvider,
+  type PhotoRestoreRequest,
+  type PhotoRestoreResult,
+} from "./infrastructure/providers";
+
+// Internal types (for advanced usage)
+export type {
+  PhotoRestoreOptions,
+  PhotoRestoreInput,
+  PhotoRestoreServiceResult,
+} from "./domain/types";

package/src/domains/photo-restoration/infrastructure/providers/gemini-photo-restore.provider.ts

@@ -0,0 +1,111 @@
+/**
+ * Gemini Photo Restore Provider
+ * Implements IPhotoRestoreProvider for content package integration
+ */
+
+import { photoRestoreService } from "../services/photo-restore.service";
+import { prepareImage } from "../../../../infrastructure/utils/image-preparer.util";
+
+declare const __DEV__: boolean;
+
+/**
+ * Provider interface matching content package's IPhotoRestoreProvider
+ * Re-defined here to avoid cross-package dependency
+ */
+export interface PhotoRestoreRequest {
+  imageUri: string;
+  userId: string;
+  options?: {
+    fixScratches?: boolean;
+    enhanceFaces?: boolean;
+    colorize?: boolean;
+  };
+}
+
+export interface PhotoRestoreResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export interface IPhotoRestoreProvider {
+  readonly providerId: string;
+  readonly providerName: string;
+  isAvailable(): boolean;
+  restore(
+    request: PhotoRestoreRequest,
+    onProgress?: (progress: number) => void
+  ): Promise<PhotoRestoreResult>;
+}
+
+class GeminiPhotoRestoreProvider implements IPhotoRestoreProvider {
+  readonly providerId = "gemini";
+  readonly providerName = "Google Gemini";
+
+  isAvailable(): boolean {
+    return true;
+  }
+
+  async restore(
+    request: PhotoRestoreRequest,
+    onProgress?: (progress: number) => void
+  ): Promise<PhotoRestoreResult> {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiPhotoRestoreProvider] Starting restore");
+    }
+
+    try {
+      onProgress?.(10);
+
+      const prepared = await prepareImage(request.imageUri);
+      onProgress?.(30);
+
+      const result = await photoRestoreService.restore({
+        base64: prepared.base64,
+        mimeType: prepared.mimeType,
+        options: {
+          fixScratches: request.options?.fixScratches,
+          enhanceFaces: request.options?.enhanceFaces,
+          colorize: request.options?.colorize,
+        },
+      });
+
+      onProgress?.(90);
+
+      if (!result.success) {
+        return { success: false, error: result.error };
+      }
+
+      const imageUrl = result.imageBase64
+        ? `data:${result.mimeType || "image/png"};base64,${result.imageBase64}`
+        : result.imageUrl;
+
+      onProgress?.(100);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[GeminiPhotoRestoreProvider] Completed");
+      }
+
+      return {
+        success: true,
+        imageUrl,
+        imageBase64: result.imageBase64,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[GeminiPhotoRestoreProvider] Error:", message);
+      }
+
+      return { success: false, error: message };
+    }
+  }
+}
+
+export const geminiPhotoRestoreProvider = new GeminiPhotoRestoreProvider();

package/src/domains/photo-restoration/infrastructure/providers/index.ts

@@ -0,0 +1,6 @@
+export {
+  geminiPhotoRestoreProvider,
+  type IPhotoRestoreProvider,
+  type PhotoRestoreRequest,
+  type PhotoRestoreResult,
+} from "./gemini-photo-restore.provider";

package/src/domains/photo-restoration/infrastructure/services/index.ts

@@ -0,0 +1 @@
+export { photoRestoreService } from "./photo-restore.service";

package/src/domains/photo-restoration/infrastructure/services/photo-restore.service.ts

@@ -0,0 +1,82 @@
+/**
+ * Photo Restore Service
+ */
+
+import { geminiImageEditService } from "../../../../infrastructure/services/gemini-image-edit.service";
+import type {
+  PhotoRestoreInput,
+  PhotoRestoreServiceResult,
+  PhotoRestoreOptions,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+function buildPrompt(options?: PhotoRestoreOptions): string {
+  const parts = [
+    "Restore this old or damaged photo to its original quality.",
+    "Remove scratches, creases, tears, and any damage marks.",
+    "Fix faded or discolored areas.",
+    "Restore missing or damaged parts of the image.",
+    "Maintain the original style and era of the photograph.",
+  ];
+
+  if (options?.fixScratches !== false) {
+    parts.push("Pay special attention to removing scratches and fold lines.");
+  }
+
+  if (options?.enhanceFaces !== false) {
+    parts.push("Carefully restore and enhance facial features while keeping them natural.");
+  }
+
+  if (options?.colorize) {
+    parts.push("If the image is black and white, colorize it naturally.");
+  }
+
+  parts.push("Preserve the authentic vintage feel while improving clarity and quality.");
+
+  return parts.join(" ");
+}
+
+class PhotoRestoreService {
+  async restore(input: PhotoRestoreInput): Promise<PhotoRestoreServiceResult> {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[PhotoRestoreService] Starting");
+    }
+
+    try {
+      const prompt = buildPrompt(input.options);
+
+      const result = await geminiImageEditService.editImage(prompt, [
+        { base64: input.base64, mimeType: input.mimeType },
+      ]);
+
+      if (!result.imageBase64 && !result.imageUrl) {
+        return { success: false, error: "No image returned" };
+      }
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[PhotoRestoreService] Completed successfully");
+      }
+
+      return {
+        success: true,
+        imageUrl: result.imageUrl,
+        imageBase64: result.imageBase64,
+        mimeType: result.mimeType,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[PhotoRestoreService] Error:", message);
+      }
+
+      return { success: false, error: message };
+    }
+  }
+}
+
+export const photoRestoreService = new PhotoRestoreService();

package/src/domains/photo-restoration/infrastructure/utils/index.ts

@@ -0,0 +1,4 @@
+/**
+ * Re-export from shared utils for backwards compatibility
+ */
+export { prepareImage, type PreparedImage } from "../../../../infrastructure/utils/image-preparer.util";

package/src/domains/upscaling/index.ts

@@ -1,33 +1,21 @@
 /**
  * Upscaling Domain - Public API
  *
- * Clean Architecture:
- * - domain: Core types (no dependencies)
- * - application: Use cases (orchestration)
- * - infrastructure: External services
- * - presentation: React hooks
+ * Exports GeminiUpscaleProvider for use with content package registry
  */
 
-// Types (Domain Layer)
+// Provider (implements IUpscaleProvider)
+export {
+  geminiUpscaleProvider,
+  type IUpscaleProvider,
+  type UpscaleRequest,
+  type UpscaleResult,
+} from "./infrastructure/providers";
+
+// Internal types (for advanced usage)
 export type {
   UpscaleScaleFactor,
   UpscaleOptions,
   UpscaleInput,
-  UpscaleResult,
   PreparedImage,
-  UseUpscaleConfig,
-  UseUpscaleReturn,
 } from "./domain/types";
-
-// Use Cases (Application Layer)
-export {
-  upscaleImageUseCase,
-  type UpscaleImageRequest,
-  type UpscaleImageResponse,
-} from "./application";
-
-// Services (Infrastructure Layer)
-export { upscaleService, prepareImage } from "./infrastructure";
-
-// Hooks (Presentation Layer)
-export { useUpscale } from "./presentation";

package/src/domains/upscaling/infrastructure/index.ts

@@ -1,2 +1,3 @@
 export * from "./services";
 export * from "./utils";
+export * from "./providers";

package/src/domains/upscaling/infrastructure/providers/gemini-upscale.provider.ts

@@ -0,0 +1,109 @@
+/**
+ * Gemini Upscale Provider
+ * Implements IUpscaleProvider for content package integration
+ */
+
+import { upscaleService } from "../services/upscale.service";
+import { prepareImage } from "../../../../infrastructure/utils/image-preparer.util";
+
+declare const __DEV__: boolean;
+
+/**
+ * Provider interface matching content package's IUpscaleProvider
+ * Re-defined here to avoid cross-package dependency
+ */
+export interface UpscaleRequest {
+  imageUri: string;
+  userId: string;
+  options?: {
+    scaleFactor?: 2 | 4 | 8;
+    enhanceFaces?: boolean;
+  };
+}
+
+export interface UpscaleResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export interface IUpscaleProvider {
+  readonly providerId: string;
+  readonly providerName: string;
+  isAvailable(): boolean;
+  upscale(
+    request: UpscaleRequest,
+    onProgress?: (progress: number) => void
+  ): Promise<UpscaleResult>;
+}
+
+class GeminiUpscaleProvider implements IUpscaleProvider {
+  readonly providerId = "gemini";
+  readonly providerName = "Google Gemini";
+
+  isAvailable(): boolean {
+    return true;
+  }
+
+  async upscale(
+    request: UpscaleRequest,
+    onProgress?: (progress: number) => void
+  ): Promise<UpscaleResult> {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiUpscaleProvider] Starting upscale");
+    }
+
+    try {
+      onProgress?.(10);
+
+      const prepared = await prepareImage(request.imageUri);
+      onProgress?.(30);
+
+      const result = await upscaleService.upscale({
+        base64: prepared.base64,
+        mimeType: prepared.mimeType,
+        options: {
+          scaleFactor: request.options?.scaleFactor || 2,
+          enhanceFaces: request.options?.enhanceFaces,
+        },
+      });
+
+      onProgress?.(90);
+
+      if (!result.success) {
+        return { success: false, error: result.error };
+      }
+
+      const imageUrl = result.imageBase64
+        ? `data:${result.mimeType || "image/png"};base64,${result.imageBase64}`
+        : result.imageUrl;
+
+      onProgress?.(100);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[GeminiUpscaleProvider] Completed");
+      }
+
+      return {
+        success: true,
+        imageUrl,
+        imageBase64: result.imageBase64,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[GeminiUpscaleProvider] Error:", message);
+      }
+
+      return { success: false, error: message };
+    }
+  }
+}
+
+export const geminiUpscaleProvider = new GeminiUpscaleProvider();

package/src/domains/upscaling/infrastructure/providers/index.ts

@@ -0,0 +1,6 @@
+export {
+  geminiUpscaleProvider,
+  type IUpscaleProvider,
+  type UpscaleRequest,
+  type UpscaleResult,
+} from "./gemini-upscale.provider";

package/src/domains/upscaling/infrastructure/utils/index.ts

@@ -1 +1,4 @@
-export { prepareImage } from "./image-preparer.util";
+/**
+ * Re-export from shared utils for backwards compatibility
+ */
+export { prepareImage, type PreparedImage } from "../../../../infrastructure/utils/image-preparer.util";

package/src/index.ts

@@ -79,9 +79,12 @@ export {
 
 export type {
   AIProviderConfig,
+  GeminiProviderConfig,
+  IAIProvider,
   JobSubmission,
   JobStatus,
   SubscribeOptions,
+  AIJobStatusType,
   UpscaleScaleFactor,
   UpscaleOptions,
   UpscaleInput,
@@ -113,19 +116,13 @@ export type {
 // DOMAINS - DDD-organized features
 // =============================================================================
 
-// Upscaling Domain
-export {
-  useUpscale,
-  upscaleImageUseCase,
-  upscaleService,
-  prepareImage,
-} from "./domains/upscaling";
+// Upscaling Domain - Provider for content package registry
+export { geminiUpscaleProvider } from "./domains/upscaling";
 
 export type {
-  UseUpscaleConfig,
-  UseUpscaleReturn,
-  UpscaleImageRequest,
-  UpscaleImageResponse,
+  IUpscaleProvider,
+  UpscaleRequest as GeminiUpscaleRequest,
+  UpscaleResult as GeminiUpscaleResult,
   PreparedImage,
 } from "./domains/upscaling";
 

package/src/infrastructure/job/JobManager.ts

@@ -3,25 +3,20 @@
  * Handles async job submission, tracking, and status management
  */
 
-declare const __DEV__: boolean;
+import type {
+  JobSubmission,
+  JobStatus,
+  AIJobStatusType,
+} from "@umituz/react-native-ai-generation-content";
 
-export interface JobSubmission {
-  requestId: string;
-  statusUrl?: string;
-  responseUrl?: string;
-}
+export type { JobSubmission, JobStatus };
 
-export interface JobStatus {
-  status: "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
-  logs?: Array<{ message: string; level: string; timestamp?: string }>;
-  queuePosition?: number;
-  eta?: number;
-}
+declare const __DEV__: boolean;
 
 interface PendingJob {
   model: string;
   input: Record<string, unknown>;
-  status: JobStatus["status"];
+  status: AIJobStatusType;
   result?: unknown;
   error?: string;
 }
@@ -81,7 +76,7 @@ export class JobManager {
     return job.result as T;
   }
 
-  updateJobStatus(requestId: string, status: JobStatus["status"]): void {
+  updateJobStatus(requestId: string, status: AIJobStatusType): void {
     const job = this.pendingJobs.get(requestId);
     if (job) {
       job.status = status;

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

@@ -1,34 +1,34 @@
 /**
  * Gemini Provider
  * Main AI provider implementation for Google Gemini
+ * Implements IAIProvider for unified orchestration
  */
 
+import type {
+  IAIProvider,
+  AIProviderConfig,
+  JobSubmission,
+  JobStatus,
+  SubscribeOptions,
+} from "@umituz/react-native-ai-generation-content";
 import type {
   GeminiImageInput,
   GeminiImageGenerationResult,
 } from "../../domain/entities";
 import { geminiImageGenerationService } from "./gemini-image-generation.service";
 import { geminiImageEditService } from "./gemini-image-edit.service";
-import { providerInitializer, type AIProviderConfig } from "./provider-initializer";
+import { providerInitializer, type GeminiProviderConfig } from "./provider-initializer";
 import { jobProcessor } from "./job-processor";
 import { generationExecutor } from "./generation-executor";
-import type { JobSubmission, JobStatus } from "../job/JobManager";
-
-export type { AIProviderConfig, JobSubmission, JobStatus };
 
-export interface SubscribeOptions<T = unknown> {
-  timeoutMs?: number;
-  onQueueUpdate?: (status: JobStatus) => void;
-  onProgress?: (progress: number) => void;
-  onResult?: (result: T) => void;
-}
+export type { GeminiProviderConfig };
 
-export class GeminiProvider {
+export class GeminiProvider implements IAIProvider {
   readonly providerId = "gemini";
   readonly providerName = "Google Gemini";
 
   initialize(config: AIProviderConfig): void {
-    providerInitializer.initialize(config);
+    providerInitializer.initialize(config as GeminiProviderConfig);
   }
 
   isInitialized(): boolean {

package/src/infrastructure/services/index.ts

@@ -31,9 +31,14 @@ export {
   GeminiProvider,
 } from "./gemini-provider";
 
+export type { GeminiProviderConfig } from "./gemini-provider";
+export type { GeminiProviderConfig as AIProviderConfig } from "./provider-initializer";
+
+// Re-export types from generation-content for convenience
 export type {
-  AIProviderConfig,
+  IAIProvider,
+  JobSubmission,
+  JobStatus,
   SubscribeOptions,
-} from "./gemini-provider";
-
-export type { JobSubmission, JobStatus } from "../job/JobManager";
+  AIJobStatusType,
+} from "@umituz/react-native-ai-generation-content";

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

@@ -3,24 +3,20 @@
  * Handles initialization logic for Gemini Provider
  */
 
+import type { AIProviderConfig } from "@umituz/react-native-ai-generation-content";
 import type { GeminiConfig } from "../../domain/entities";
 import { geminiClientCoreService } from "./gemini-client-core.service";
 
 declare const __DEV__: boolean;
 
-export interface AIProviderConfig {
-    apiKey: string;
-    maxRetries?: number;
-    baseDelay?: number;
-    maxDelay?: number;
-    defaultTimeoutMs?: number;
-    textModel?: string;
-    textToImageModel?: string;
-    imageEditModel?: string;
+export interface GeminiProviderConfig extends AIProviderConfig {
+  textModel?: string;
+  textToImageModel?: string;
+  imageEditModel?: string;
 }
 
 export class ProviderInitializer {
-    initialize(config: AIProviderConfig): void {
+    initialize(config: GeminiProviderConfig): void {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
             // eslint-disable-next-line no-console
             console.log("[GeminiProvider] Initializing...");

package/src/infrastructure/utils/image-preparer.util.ts

@@ -1,12 +1,16 @@
 /**
  * Image Preparer Utility
  * Prepares images for Gemini API
+ * Shared utility - used by all image processing features
  */
 
-import type { PreparedImage } from "../../domains/upscaling/domain/types";
-
 declare const __DEV__: boolean;
 
+export interface PreparedImage {
+  base64: string;
+  mimeType: string;
+}
+
 function getMimeTypeFromUri(uri: string): string {
   const extension = uri.split(".").pop()?.toLowerCase();
   const mimeTypes: Record<string, string> = {
@@ -63,3 +67,8 @@ export function isValidBase64(str: string): boolean {
     return false;
   }
 }
+
+/**
+ * Alias for prepareImageFromUri for backwards compatibility
+ */
+export const prepareImage = prepareImageFromUri;

package/src/infrastructure/utils/index.ts

@@ -12,3 +12,10 @@ export {
   extractBase64Data,
   extractTextFromResponse,
 } from "./gemini-data-transformer.util";
+
+export {
+  prepareImageFromUri,
+  prepareImage,
+  isValidBase64,
+} from "./image-preparer.util";
+export type { PreparedImage } from "./image-preparer.util";

package/src/domains/upscaling/application/index.ts

@@ -1 +0,0 @@
-export * from "./use-cases";

package/src/domains/upscaling/application/use-cases/index.ts

@@ -1,5 +0,0 @@
-export {
-  upscaleImageUseCase,
-  type UpscaleImageRequest,
-  type UpscaleImageResponse,
-} from "./upscale-image.use-case";

package/src/domains/upscaling/application/use-cases/upscale-image.use-case.ts

@@ -1,73 +0,0 @@
-/**
- * Upscale Image Use Case
- *
- * Application layer: Orchestrates the upscaling flow
- * Follows Clean Architecture - use case contains application-specific business rules
- */
-
-import { upscaleService, prepareImage } from "../../infrastructure";
-import type {
-  UpscaleInput,
-  UpscaleResult,
-  UpscaleOptions,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface UpscaleImageRequest {
-  imageUri: string;
-  options?: UpscaleOptions;
-}
-
-export interface UpscaleImageResponse {
-  success: boolean;
-  imageUrl?: string;
-  imageBase64?: string;
-  mimeType?: string;
-  error?: string;
-}
-
-export async function upscaleImageUseCase(
-  request: UpscaleImageRequest
-): Promise<UpscaleImageResponse> {
-  if (__DEV__) {
-    // eslint-disable-next-line no-console
-    console.log("[UpscaleImageUseCase] Starting", {
-      scaleFactor: request.options?.scaleFactor || 2,
-    });
-  }
-
-  try {
-    // Step 1: Prepare image (convert URI to base64)
-    const prepared = await prepareImage(request.imageUri);
-
-    // Step 2: Create input for service
-    const input: UpscaleInput = {
-      base64: prepared.base64,
-      mimeType: prepared.mimeType,
-      options: request.options,
-    };
-
-    // Step 3: Execute upscaling
-    const result: UpscaleResult = await upscaleService.upscale(input);
-
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[UpscaleImageUseCase] Result:", {
-        success: result.success,
-        hasImage: !!result.imageBase64 || !!result.imageUrl,
-      });
-    }
-
-    return result;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.error("[UpscaleImageUseCase] Error:", message);
-    }
-
-    return { success: false, error: message };
-  }
-}

package/src/domains/upscaling/infrastructure/utils/image-preparer.util.ts

@@ -1,55 +0,0 @@
-/**
- * Image Preparer Utility
- */
-
-import type { PreparedImage } from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-function getMimeType(uri: string): string {
-  const ext = uri.split(".").pop()?.toLowerCase();
-  const types: Record<string, string> = {
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-  };
-  return types[ext || ""] || "image/jpeg";
-}
-
-function extractBase64(dataUrl: string): string {
-  const match = dataUrl.match(/^data:[^;]+;base64,(.+)$/);
-  return match ? match[1] : dataUrl;
-}
-
-export async function prepareImage(uri: string): Promise<PreparedImage> {
-  if (__DEV__) {
-    // eslint-disable-next-line no-console
-    console.log("[ImagePreparer] Preparing image");
-  }
-
-  if (uri.startsWith("data:")) {
-    const mimeMatch = uri.match(/^data:([^;]+);base64,/);
-    return {
-      base64: extractBase64(uri),
-      mimeType: mimeMatch ? mimeMatch[1] : "image/jpeg",
-    };
-  }
-
-  const response = await fetch(uri);
-  const blob = await response.blob();
-
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onloadend = () => {
-      const dataUrl = reader.result as string;
-      resolve({
-        base64: extractBase64(dataUrl),
-        mimeType: blob.type || getMimeType(uri),
-      });
-    };
-    reader.onerror = () => reject(new Error("Failed to read image"));
-    reader.readAsDataURL(blob);
-  });
-}

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

@@ -1 +0,0 @@
-export { useUpscale } from "./useUpscale";

package/src/domains/upscaling/presentation/hooks/useUpscale.ts

@@ -1,114 +0,0 @@
-/**
- * useUpscale Hook
- *
- * Presentation layer: React-specific abstraction for upscaling
- * Provides a clean API hiding complexity (Deep Module pattern)
- */
-
-import { useState, useCallback } from "react";
-import { upscaleImageUseCase } from "../../application";
-import type {
-  UpscaleOptions,
-  UpscaleScaleFactor,
-  UseUpscaleConfig,
-  UseUpscaleReturn,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-const DEFAULT_SCALE_FACTOR: UpscaleScaleFactor = 2;
-
-export function useUpscale(config?: UseUpscaleConfig): UseUpscaleReturn {
-  const [imageUri, setImageUri] = useState<string | null>(null);
-  const [processedUrl, setProcessedUrl] = useState<string | null>(null);
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [progress, setProgress] = useState(0);
-  const [error, setError] = useState<string | null>(null);
-
-  const reset = useCallback(() => {
-    setImageUri(null);
-    setProcessedUrl(null);
-    setIsProcessing(false);
-    setProgress(0);
-    setError(null);
-  }, []);
-
-  const process = useCallback(async () => {
-    if (!imageUri) {
-      setError("No image selected");
-      return;
-    }
-
-    setIsProcessing(true);
-    setProgress(10);
-    setError(null);
-    setProcessedUrl(null);
-
-    if (__DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[useUpscale] Processing started");
-    }
-
-    try {
-      setProgress(30);
-
-      const options: UpscaleOptions = {
-        scaleFactor: config?.defaultScaleFactor || DEFAULT_SCALE_FACTOR,
-      };
-
-      setProgress(50);
-
-      const result = await upscaleImageUseCase({
-        imageUri,
-        options,
-      });
-
-      setProgress(90);
-
-      if (!result.success) {
-        throw new Error(result.error || "Upscale failed");
-      }
-
-      const resultUrl = result.imageBase64
-        ? `data:${result.mimeType || "image/png"};base64,${result.imageBase64}`
-        : result.imageUrl || null;
-
-      setProcessedUrl(resultUrl);
-      setProgress(100);
-
-      if (__DEV__) {
-        // eslint-disable-next-line no-console
-        console.log("[useUpscale] Processing completed");
-      }
-
-      if (config?.onSuccess && result.success) {
-        config.onSuccess(result);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(message);
-
-      if (__DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[useUpscale] Error:", message);
-      }
-
-      if (config?.onError) {
-        config.onError(message);
-      }
-    } finally {
-      setIsProcessing(false);
-    }
-  }, [imageUri, config]);
-
-  return {
-    imageUri,
-    processedUrl,
-    isProcessing,
-    progress,
-    error,
-    setImageUri,
-    process,
-    reset,
-  };
-}

package/src/domains/upscaling/presentation/index.ts

@@ -1 +0,0 @@
-export * from "./hooks";