@sanctum-key/react-native-sdk 1.0.35 → 1.0.37

package/src/components/KYCElements/IDCardCapture.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react';
-import { View, Text, StyleSheet, Image, ScrollView, Platform, ActivityIndicator, TouchableOpacity, useWindowDimensions, Alert } from 'react-native';
+import { View, Text, StyleSheet, Image, ScrollView, Platform, ActivityIndicator, TouchableOpacity, useWindowDimensions } from 'react-native';
 import { showAlert } from '../../utils/platformAlert';
 import { EnhancedCameraView } from '../EnhancedCameraView';
 import { TemplateComponent, LocalizedText, GovernmentDocumentType, ISilentCaptureResult, IBbox, GovernmentDocumentTypeShorted, GovernmentDocumentTypeBackend } from '../../types/KYC.types';
@@ -554,43 +554,34 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
     if (isProcessingCaptureRef.current) return;
     if (scanPhaseRef.current === 'barcode') return;
     if (isAnalyzingRef.current) return;
-
+  
     if (result.success && result.path) {
       setSilentCaptureResult((prev) => ({ ...prev, isAnalyzing: true, success: false, error: '' }));
-
-      const safeCapturePath = Platform.OS === 'ios' && !result.path.startsWith('file://') 
-        ? `file://${result.path}` 
-        : result.path;
-
+  
+      const safeCapturePath = Platform.OS === 'ios' && !result.path.startsWith('file://') ? `file://${result.path}` : result.path;
       let templatePath = capturedImages[currentSide]?.templatePath || '';
       let templateBbox: IBbox | undefined;
       let templateResponse: any;
-
+  
       if (!selectedDocumentType) {
         setSilentCaptureResult((prev) => ({ ...prev, isAnalyzing: false, success: false, error: 'Document type not selected' }));
         return;
       }
-
+  
       const issuingSubdivision = selectedDocumentType.region !== 'root' ? selectedDocumentType.region : undefined;
-
-      // 🚨 WATCHDOG TIMER: If the iOS network drops and doesn't throw, this guarantees the UI unlocks after 20 seconds.
+  
+      // Subtle timeout handling without blocking pop-ups
       const watchdog = setTimeout(() => {
         if (isAnalyzingRef.current) {
           setSilentCaptureResult((prev) => ({
             ...prev,
             isAnalyzing: false,
             success: false,
-            error: state.currentLanguage === 'en' ? 'Connection timeout. Please try again.' : 'Délai de connexion dépassé. Veuillez réessayer.'
+            error: state.currentLanguage === 'en' ? 'Taking longer than expected. Hold steady.' : 'Traitement long. Veuillez rester immobile.'
           }));
-          Alert.alert(
-            state.currentLanguage === 'en' ? "Timeout" : "Délai dépassé",
-            state.currentLanguage === 'en' 
-              ? "The request took too long. Please verify your network and try again." 
-              : "La requête a pris trop de temps. Veuillez vérifier votre connexion et réessayer."
-          );
         }
       }, 20000);
-
+  
       try {
         if (!templatePath) {
           const templateType = await checkTemplateType({
@@ -600,9 +591,10 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
             postfix: currentSide,
             issuingSubdivision: issuingSubdivision
           }, env);
-
+  
           templateResponse = templateType;
           if (templateType.template_path) templatePath = templateType.template_path;
+  
           if (templateType.card_obb) {
             const obbConfidence = getObbConfidence((templateType as any).card_obb);
             if (obbConfidence !== null && obbConfidence < OBB_CONFIDENCE_THRESHOLD) {
@@ -616,21 +608,18 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
             } catch {}
           }
         }
-
+  
         const extractedCountryKey = templatePath ? templatePath.split('/')[0] : (ISO_TO_COUNTRY_NAME[countryData?.code || ''] || 'root');
         const regionMappings = getCurrentSideVerification(currentSide, extractedCountryKey);
-
         let verificationRes: any;
+  
         if (currentSide === 'front') {
           const matchedAuthMethod = getCorrespondingAuthMethod(templatePath, regionMappings.regionMapping, regionMappings.key || '', 'front');
           const mrzType = getCorrespondingMrzType(templatePath, regionMappings.regionMapping, regionMappings.key || '') || 'TD1';
-
+          
           verificationRes = await frontVerification({
             path: safeCapturePath,
-            regionMapping: {
-              authMethod: matchedAuthMethod ? [matchedAuthMethod] : [],
-              mrzTypes: mrzType ? [mrzType] : []
-            },
+            regionMapping: { authMethod: matchedAuthMethod ? [matchedAuthMethod] : [], mrzTypes: mrzType ? [mrzType] : [] },
             selectedDocumentType: GovernmentDocumentTypeShorted[selectedDocumentType?.type as keyof typeof GovernmentDocumentTypeShorted] || '',
             code: countryData?.code || '',
             currentSide,
@@ -639,19 +628,15 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
             issuingSubdivision: issuingSubdivision,
             clientSideBarcodeData: silentCaptureResult.barcode
           }, env);
-
         } else {
           logger.log("Attempting backVerification with:", { path: safeCapturePath, templatePath, side: currentSide });
           const matchedBackAuthMethod = getCorrespondingAuthMethod(templatePath, regionMappings.regionMapping, regionMappings.key || '', 'back');
           const backMrzType = getCorrespondingMrzType(templatePath, regionMappings.regionMapping, regionMappings.key || '') || '';
           const frontTemplatePath = capturedImages['front']?.templatePath || '';
-
+          
           verificationRes = await backVerification({
             path: safeCapturePath,
-            regionMapping: {
-              authMethod: matchedBackAuthMethod ? [matchedBackAuthMethod] : [],
-              mrzTypes: backMrzType ? [backMrzType] : []
-            },
+            regionMapping: { authMethod: matchedBackAuthMethod ? [matchedBackAuthMethod] : [], mrzTypes: backMrzType ? [backMrzType] : [] },
             selectedDocumentType: GovernmentDocumentTypeShorted[selectedDocumentType.type as keyof typeof GovernmentDocumentTypeShorted] || '',
             code: countryData?.code || '',
             currentSide,
@@ -662,35 +647,37 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
             frontTemplatePath: frontTemplatePath
           }, env);
         }
-
+  
         const bbox = verificationRes?.bbox || templateBbox;
         const verifiedMrz = verificationRes?.mrz ? JSON.stringify(verificationRes.mrz) : "";
-
+  
         if (isBarcodeRequired()) {
           const barcodeData = scannedBarcodeRef.current;
           const docTypeStr = selectedDocumentType!.type;
           const isHIC = docTypeStr === 'health_insurance_card';
           const isValidScan = typeof barcodeData === 'string' && ((isHIC && barcodeData.length > 0) || barcodeData.length > 50);
-
+  
           if (isValidScan) {
             logger.log('[CA Barcode] Image captured, verified & barcode ALREADY scanned! Skipping Phase 2.');
             let parsedDictionary;
+  
             if (isHIC && barcodeData.length < 50) {
               parsedDictionary = { data: { card_number: barcodeData, barcode_type: "1D" } };
             } else {
               const token = await authentification();
               parsedDictionary = await kycService.formatBarcodeData({ textInput: barcodeData, token }, env);
             }
-
+  
             const verifiedResult: ISilentCaptureResult & { region?: string } = {
               path: safeCapturePath, templatePath: templatePath, bbox: bbox, success: true,
               mrz: JSON.stringify(parsedDictionary), barcode: barcodeData, isAnalyzing: false,
               country: countryData?.code, documentType: selectedDocumentType!.type,
               region: selectedDocumentType!.region !== 'root' ? selectedDocumentType!.region : undefined,
             };
-
+            
             clearTimeout(watchdog);
             setSilentCaptureResult(verifiedResult);
+            
             if (bbox) {
               const safeBbox = bbox as IBbox;
               setBboxBySide(prev => ({ ...prev, ['back']: safeBbox }));
@@ -698,7 +685,7 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
             await autoCapture(safeCapturePath!, verifiedResult);
             return;
           }
-
+  
           logger.log('[CA Barcode] Image captured & template VERIFIED. Switching to Barcode phase.');
           clearTimeout(watchdog);
           setPendingCAImage({ path: safeCapturePath!, templateResponse, templatePath, bbox });
@@ -706,7 +693,7 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
           setSilentCaptureResult(prev => ({ ...prev, isAnalyzing: false }));
           return;
         }
-
+  
         const verifiedResult: ISilentCaptureResult & { region?: string } = {
           path: safeCapturePath, templatePath, bbox, success: true, mrz: verifiedMrz,
           isAnalyzing: false, country: countryData?.code, documentType: selectedDocumentType.type,
@@ -717,46 +704,34 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
         setSilentCaptureResult(verifiedResult);
         if (bbox) setBboxBySide(prev => ({ ...prev, [currentSide]: bbox }));
         await autoCapture(safeCapturePath, verifiedResult);
-
+  
       } catch (error: any) {
         clearTimeout(watchdog);
-        console.log("Backend Verification Error:", error);
+        const isNetworkError = !error.response || error.message === 'Network Error' || error.code === 'ECONNABORTED' || error.message?.includes('Network');
         
-        const isNetworkError = 
-          !error.response || 
-          error.message === 'Network Error' || 
-          error.code === 'ECONNABORTED' ||
-          error.message?.includes('Network');
-
-        let userFriendlyMessage = 'Verification failed. Please try again.';
-
+        // Keep UI errors extremely brief and actionable
+        let hintMessage = '';
+  
         if (isNetworkError) {
-          userFriendlyMessage = state.currentLanguage === 'en' 
-            ? 'Cannot connect to verification server. Please check your internet connection.'
-            : 'Impossible de se connecter au serveur de vérification. Veuillez vérifier votre connexion internet.';
-          
-          Alert.alert(
-            state.currentLanguage === 'en' ? "Connection Failed" : "Échec de connexion", 
-            userFriendlyMessage
-          );
+          hintMessage = state.currentLanguage === 'en' ? 'Poor connection. Retrying...' : 'Connexion faible. Nouvelle tentative...';
         } else {
           const rawMessage = (error?.message || '').toLowerCase();
           if (rawMessage.includes('impossible') || rawMessage.includes('unreadable')) {
-            userFriendlyMessage = 'Document unreadable. Please hold the camera steady in good light.';
+            hintMessage = state.currentLanguage === 'en' ? 'Move to better lighting.' : 'Améliorez l\'éclairage.';
           } else if (rawMessage.includes('country mismatch') || rawMessage.includes('pays sélectionné')) {
-            userFriendlyMessage = 'The document does not match your selected country.';
+            hintMessage = state.currentLanguage === 'en' ? 'Wrong document type.' : 'Mauvais type de document.';
           } else if (rawMessage.includes('card_not_fully_in_frame')) {
-            userFriendlyMessage = 'Move closer to the document and ensure all corners are visible.';
+            hintMessage = state.currentLanguage === 'en' ? 'Move closer.' : 'Rapprochez-vous.';
           } else if (rawMessage.includes('ne correspond pas au recto')) {
-            userFriendlyMessage = 'The back of the document does not match the front. You must scan the same ID.';
+            hintMessage = state.currentLanguage === 'en' ? 'Scan the same ID.' : 'Scannez la même pièce.';
           }
         }
-
-        setSilentCaptureResult(prev => ({ ...prev, isAnalyzing: false, success: false, error: userFriendlyMessage }));
+  
+        setSilentCaptureResult(prev => ({ ...prev, isAnalyzing: false, success: false, error: hintMessage }));
       }
     }
   };
-
+  
   useEffect(() => {
     if (scanPhase === 'barcode' && pendingCAImage && silentCaptureResult.barcode) {
       const bData = silentCaptureResult.barcode;
@@ -766,44 +741,23 @@ export const IDCardCapture: React.FC<IDCardCaptureProps> = ({ component, value =
       }
     }
   }, [scanPhase, pendingCAImage, silentCaptureResult.barcode]);
+  
 
   const handleError = (event: { message: string, name?: string, code?: string }) => {
     logger.error("Camera Error:", event);
-    
-    // Normalize the error to lowercase for easy checking
     const errString = `${event.message} ${event.name} ${event.code}`.toLowerCase();
     
-    let friendlyMessage = state.currentLanguage === 'en' 
-      ? 'An unknown camera error occurred.' 
-      : 'Une erreur de caméra inconnue est survenue.';
-
-    // 1. Detect Hardware Lock (Camera in use by Zoom, Teams, or another app)
-    if (
-      errString.includes('notreadableerror') || 
-      errString.includes('trackstarterror') || 
-      errString.includes('in use') || 
-      errString.includes('concurrent') ||
-      errString.includes('camera unavailable')
-    ) {
-      friendlyMessage = state.currentLanguage === 'en'
-        ? 'Your camera is currently being used by another application (like Zoom or Teams). Please close the other app and try again.'
-        : 'Votre caméra est actuellement utilisée par une autre application. Veuillez fermer l\'autre application et réessayer.';
-    } 
-    // 2. Detect Permission Denied
-    else if (errString.includes('notallowederror') || errString.includes('permission')) {
-      friendlyMessage = state.currentLanguage === 'en'
-        ? 'Camera permission denied. Please allow camera access in your settings to proceed.'
-        : 'Autorisation de la caméra refusée. Veuillez autoriser l\'accès dans vos paramètres.';
-    }
-    // 3. Detect No Camera Found
-    else if (errString.includes('notfounderror') || errString.includes('no camera')) {
-      friendlyMessage = state.currentLanguage === 'en'
-        ? 'No camera detected on this device.'
-        : 'Aucune caméra détectée sur cet appareil.';
+    let friendlyMessage = state.currentLanguage === 'en' ? 'Camera error.' : 'Erreur de caméra.';
+  
+    if (errString.includes('notreadableerror') || errString.includes('trackstarterror') || errString.includes('in use') || errString.includes('concurrent') || errString.includes('camera unavailable')) {
+      friendlyMessage = state.currentLanguage === 'en' ? 'Camera is in use by another app.' : 'Caméra utilisée par une autre application.';
+    } else if (errString.includes('notallowederror') || errString.includes('permission')) {
+      friendlyMessage = state.currentLanguage === 'en' ? 'Allow camera access in settings.' : 'Autorisez l\'accès à la caméra.';
+    } else if (errString.includes('notfounderror') || errString.includes('no camera')) {
+      friendlyMessage = state.currentLanguage === 'en' ? 'No camera detected.' : 'Aucune caméra détectée.';
     }
-
-    showAlert(state.currentLanguage === 'en' ? 'Camera Error' : 'Erreur de Caméra', friendlyMessage);
-    
+  
+    showAlert(state.currentLanguage === 'en' ? 'Camera Error' : 'Erreur', friendlyMessage);
     setShowCamera(false);
     setIsProcessingCapture(false);
   };

package/src/modules/camera/VisionCameraModule.ts

@@ -3,51 +3,40 @@ import { Camera, CameraDevice, CameraPermissionStatus, PhotoFile } from 'react-n
 
 /**
  * Backward-compatible file copy function
- * Tries new File API first (Expo SDK 54+), then legacy API, then regular import for SDK 53
  */
 async function copyFileCompat(from: string, to: string): Promise<void> {
   // Try new File API first (Expo SDK 54+)
   try {
-    // @ts-ignore - File API might not be in types yet
     const { File } = require('expo-file-system');
     if (File && typeof File === 'function') {
       const sourceFile = new File(from);
       const destFile = new File(to);
-      // File.copy() is synchronous but may throw
       sourceFile.copy(destFile);
       return;
     }
   } catch (error) {
     // New API not available or failed, try legacy
-    // Continue to legacy API
   }
 
   // Try legacy API from expo-file-system/legacy (Expo SDK 54+)
-  // This is the recommended way to avoid deprecation warnings
   try {
-    // @ts-ignore - legacy export might not be in types
-    const LegacyFileSystem = require('expo-file-system');
+    // FIX: Appended /legacy to the require string
+    const LegacyFileSystem = require('expo-file-system/legacy');
     if (LegacyFileSystem && LegacyFileSystem.copyAsync && typeof LegacyFileSystem.copyAsync === 'function') {
       await LegacyFileSystem.copyAsync({ from, to });
       return;
     }
   } catch (error) {
-    // Legacy not available (SDK 53 or earlier), fall through to regular import
-    // Check if it's a "module not found" error (SDK 53) vs other error
     const errorMessage = error instanceof Error ? error.message : String(error);
     if (errorMessage.includes('Cannot find module') || errorMessage.includes('Module not found')) {
-      // SDK 53 or earlier - use regular import as fallback
-      // This will show a deprecation warning on SDK 54+, but is necessary for SDK 53 compatibility
+      // SDK 53 fallback logic...
     } else {
-      // Other error, re-throw
       throw new Error(`Unable to copy file: legacy FileSystem API error. Error: ${errorMessage}`);
     }
   }
 
   // Fallback to regular import for SDK 53 and earlier
-  // Note: This will show a deprecation warning on SDK 54+, but is necessary for backward compatibility
   try {
-    // @ts-ignore
     const FileSystem = require('expo-file-system');
     if (FileSystem && FileSystem.copyAsync && typeof FileSystem.copyAsync === 'function') {
       await FileSystem.copyAsync({ from, to });
@@ -63,12 +52,9 @@ async function copyFileCompat(from: string, to: string): Promise<void> {
 
 /**
  * Get document directory path in a backward-compatible way
- * Supports SDK 53 (regular import) and SDK 54+ (legacy or new API)
  */
 function getDocumentDirectory(): string {
   try {
-    // Try new Paths API first (Expo SDK 54+)
-    // @ts-ignore
     const { Paths } = require('expo-file-system');
     if (Paths?.document) {
       return Paths.document.uri;
@@ -77,29 +63,20 @@ function getDocumentDirectory(): string {
     // New API not available, try legacy
   }
 
-  // Try legacy API from expo-file-system/legacy (Expo SDK 54+)
-  // This is the recommended way to avoid deprecation warnings
   try {
-    // @ts-ignore
-    const LegacyFileSystem = require('expo-file-system');
+    // FIX: Appended /legacy to the require string
+    const LegacyFileSystem = require('expo-file-system/legacy');
     if (LegacyFileSystem && LegacyFileSystem.documentDirectory) {
       return LegacyFileSystem.documentDirectory;
     }
   } catch (error) {
-    // Legacy not available (SDK 53 or earlier), fall through to regular import
     const errorMessage = error instanceof Error ? error.message : String(error);
     if (errorMessage.includes('Cannot find module') || errorMessage.includes('Module not found')) {
-      // SDK 53 or earlier - use regular import as fallback
-      // This will show a deprecation warning on SDK 54+, but is necessary for SDK 53 compatibility
-    } else {
-      // Other error, continue to fallback
+      // SDK 53 fallback logic...
     }
   }
 
-  // Fallback to regular import for SDK 53 and earlier
-  // Note: This will show a deprecation warning on SDK 54+, but is necessary for backward compatibility
   try {
-    // @ts-ignore
     const FileSystem = require('expo-file-system');
     if (FileSystem && FileSystem.documentDirectory) {
       return FileSystem.documentDirectory;
@@ -133,50 +110,35 @@ export class VisionCameraModule {
     return VisionCameraModule.instance;
   }
 
-  /**
-   * Get available camera devices
-   */
   async getCameraDevices(): Promise<CameraDevice[]> {
     try {
-      const devices = Camera.getAvailableCameraDevices();
-      return devices;
+      return Camera.getAvailableCameraDevices();
     } catch (error) {
       console.error('Error getting camera devices:', error);
       return [];
     }
   }
 
-  /**
-   * Get the best available device for selfies (front camera)
-   */
   async getFrontCameraDevice(): Promise<CameraDevice | null> {
     try {
       const devices = await this.getCameraDevices();
-      const frontCamera = devices.find(device => device.position === 'front');
-      return frontCamera || null;
+      return devices.find(device => device.position === 'front') || null;
     } catch (error) {
       console.error('Error getting front camera:', error);
       return null;
     }
   }
 
-  /**
-   * Get the best available device for document capture (back camera)
-   */
   async getBackCameraDevice(): Promise<CameraDevice | null> {
     try {
       const devices = await this.getCameraDevices();
-      const backCamera = devices.find(device => device.position === 'back');
-      return backCamera || null;
+      return devices.find(device => device.position === 'back') || null;
     } catch (error) {
       console.error('Error getting back camera:', error);
       return null;
     }
   }
 
-  /**
-   * Request camera permissions
-   */
   async requestCameraPermission(): Promise<boolean> {
     try {
       const permission = await Camera.requestCameraPermission();
@@ -187,9 +149,6 @@ export class VisionCameraModule {
     }
   }
 
-  /**
-   * Request microphone permissions
-   */
   async requestMicrophonePermission(): Promise<boolean> {
     try {
       const permission = await Camera.requestMicrophonePermission();
@@ -200,30 +159,18 @@ export class VisionCameraModule {
     }
   }
 
-  /**
-   * Get current permission status
-   */
   async getPermissionStatus(): Promise<CameraPermissions> {
     try {
-      const cameraStatus = await Camera.getCameraPermissionStatus();
-      const microphoneStatus = await Camera.getMicrophonePermissionStatus();
-
       return {
-        camera: cameraStatus,
-        microphone: microphoneStatus,
+        camera: await Camera.getCameraPermissionStatus(),
+        microphone: await Camera.getMicrophonePermissionStatus(),
       };
     } catch (error) {
       console.error('Error getting permission status:', error);
-      return {
-        camera: 'denied',
-        microphone: 'denied',
-      };
+      return { camera: 'denied', microphone: 'denied' };
     }
   }
 
-  /**
-   * Check if all required permissions are granted
-   */
   async hasAllPermissions(): Promise<boolean> {
     try {
       const status = await this.getPermissionStatus();
@@ -235,16 +182,12 @@ export class VisionCameraModule {
     }
   }
 
-  /**
-   * Request all required permissions
-   */
   async requestAllPermissions(): Promise<boolean> {
     try {
       const [cameraGranted, microphoneGranted] = await Promise.all([
         this.requestCameraPermission(),
         this.requestMicrophonePermission(),
       ]);
-
       return cameraGranted && microphoneGranted;
     } catch (error) {
       console.error('Error requesting permissions:', error);
@@ -252,15 +195,9 @@ export class VisionCameraModule {
     }
   }
 
-  /**
-   * Check if camera is available
-   */
   async isCameraAvailable(): Promise<boolean> {
     try {
-      if (Platform.OS === 'web') {
-        return false; // Vision Camera doesn't support web
-      }
-
+      if (Platform.OS === 'web') return false;
       const devices = await this.getCameraDevices();
       return devices.length > 0;
     } catch (error) {
@@ -269,9 +206,6 @@ export class VisionCameraModule {
     }
   }
 
-  /**
-   * Process photo capture result
-   */
   async processPhotoResult(photo: PhotoFile): Promise<CameraCaptureResult> {
     try {
       const documentDir = getDocumentDirectory();
@@ -292,41 +226,19 @@ export class VisionCameraModule {
     }
   }
 
-  /**
-   * Legacy method for backward compatibility
-   * @deprecated Use VisionCameraView component instead
-   */
   async openCameraWithInstructions(instructions: string): Promise<CameraCaptureResult> {
     console.warn('openCameraWithInstructions is deprecated. Use VisionCameraView component instead.');
-
     try {
       const hasPermissions = await this.requestAllPermissions();
-      if (!hasPermissions) {
-        return {
-          success: false,
-          error: 'Camera permissions not granted',
-        };
-      }
-
+      if (!hasPermissions) return { success: false, error: 'Camera permissions not granted' };
+      
       const isAvailable = await this.isCameraAvailable();
-      if (!isAvailable) {
-        return {
-          success: false,
-          error: 'Camera not available',
-        };
-      }
+      if (!isAvailable) return { success: false, error: 'Camera not available' };
 
-      // Return a placeholder result since this should be handled by the component
-      return {
-        success: true,
-        path: `mock_photo_${Date.now()}.jpg`,
-      };
+      return { success: true, path: `mock_photo_${Date.now()}.jpg` };
     } catch (error) {
       console.error('Error in openCameraWithInstructions:', error);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error',
-      };
+      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
     }
   }
 }

package/src/utils/pathToBase64.ts

@@ -10,10 +10,9 @@ export async function pathToBase64(uri: string): Promise<string> {
   // Try Expo FileSystem if available (React Native + Expo)
   try {
     // Try legacy API from expo-file-system/legacy first (Expo SDK 54+)
-    // This is the recommended way to avoid deprecation warnings
     try {
-      // @ts-ignore - legacy export might not be in types
-      const LegacyFileSystem = require('expo-file-system');
+      // FIX: Appended /legacy to the require string
+      const LegacyFileSystem = require('expo-file-system/legacy');
       if (LegacyFileSystem?.readAsStringAsync) {
         const base64 = await LegacyFileSystem.readAsStringAsync(uri, { encoding: LegacyFileSystem.EncodingType.Base64 });
         if (base64) return base64;
@@ -30,13 +29,12 @@ export async function pathToBase64(uri: string): Promise<string> {
           if (base64) return base64;
         }
       }
-      // If it's a different error, continue to other strategies
     }
   } catch (_) {
     // All FileSystem APIs failed, fall back to other strategies (fetch + FileReader)
   }
 
-  // Generic fetch + FileReader strategy (works on web; often works on RN for file:// URIs)
+  // Generic fetch + FileReader strategy
   try {
     const response = await fetch(uri);
     const blob = await response.blob();
@@ -58,6 +56,4 @@ export async function pathToBase64(uri: string): Promise<string> {
   throw new Error('pathToBase64: unable to convert uri to base64');
 }
 
-export default pathToBase64;
-
-
+export default pathToBase64;