@myazahq/kyc-sdk-react-native 2.5.0 → 3.0.0

package/android/src/main/java/com/margelo/nitro/myazakyc/MlKitModelReadiness.kt

@@ -0,0 +1,154 @@
+package com.margelo.nitro.myazakyc
+
+import co.myazahq.kyc.rn.BuildConfig
+import com.google.android.gms.common.api.OptionalModuleApi
+import com.google.android.gms.common.moduleinstall.InstallStatusListener
+import com.google.android.gms.common.moduleinstall.ModuleInstall
+import com.google.android.gms.common.moduleinstall.ModuleInstallClient
+import com.google.android.gms.common.moduleinstall.ModuleInstallRequest
+import com.google.android.gms.common.moduleinstall.ModuleInstallStatusUpdate
+import com.margelo.nitro.NitroModules
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * The readiness gate both ML Kit detectors share.
+ *
+ * The default build fetches ML Kit's models through Play Services instead of
+ * bundling them (android/build.gradle), which is what keeps ~18.5 MB per device
+ * out of the APK. The cost is a window where the detector cannot run: first
+ * launch before the download completes, or a device with no GMS at all.
+ *
+ * Neither detector can report that through its own result. A face detector
+ * answers in `FaceResult`, where a missing model and an empty frame are both
+ * `faceCount: 0`; a text recogniser answers in `TextResult`, where both are an
+ * empty `lines` array. So a user on a fresh install would watch "position your
+ * face" forever, or aim at a passport that never auto-captures, with nothing to
+ * explain it. Hence a separate, explicit contract, checked before the camera
+ * opens rather than inferred per frame.
+ *
+ * Two properties make it actually settle, and both were missing once:
+ *  - The install is URGENT (`installModules`). `deferredInstall` leaves the
+ *    timing to Play Services, which may wait for an idle, charging phone; right
+ *    for a model somebody might want next week, wrong for one a person is
+ *    waiting on now.
+ *  - The answer is REFRESHED. `isModelReady` is a synchronous Nitro call and
+ *    `areModulesAvailable` is asynchronous, so it returns the cached flag, but
+ *    while the flag is false each call also starts a background re-check. The
+ *    cache used to be set once at flow start and never again, so a download that
+ *    finished a few seconds later was never noticed and the step gave up.
+ */
+class MlKitModelReadiness(private val api: OptionalModuleApi) {
+  // A bundled build has the model in the APK, so there is nothing to wait for
+  // and nothing to ask. Asking anyway would be worse than useless: Play
+  // Services answers about its OWN optional modules, so it would report "not
+  // available" and strand a build that works perfectly offline — which is the
+  // exact scenario the bundled flag exists to serve.
+  @Volatile private var ready = BuildConfig.BUNDLED_ML_KIT
+  @Volatile private var checking = false
+  @Volatile private var installing = false
+
+  fun isReady(): Boolean {
+    if (!ready) refresh()
+    return ready
+  }
+
+  /**
+   * Ask Play Services for the model, returning true once it is usable, and
+   * request an urgent install when it is not.
+   *
+   * Safe to call repeatedly; returns immediately when already ready. Blocking
+   * — callers run it inside a Nitro `Promise.async`.
+   */
+  fun prepare(): Boolean {
+    if (ready) return true
+
+    val ctx = NitroModules.applicationContext
+      ?: return false // No context — cannot ask Play Services anything.
+
+    val latch = CountDownLatch(1)
+    try {
+      val client = ModuleInstall.getClient(ctx)
+      client.areModulesAvailable(api)
+        .addOnSuccessListener { response ->
+          if (response.areModulesAvailable()) ready = true else requestInstall(client)
+          latch.countDown()
+        }
+        .addOnFailureListener {
+          // Thrown on devices without Google Play Services at all (Huawei, bare
+          // AOSP). Not an error to retry — it will never succeed on this device.
+          // Such orgs should build with `myazaKycBundledMlKit = true`.
+          latch.countDown()
+        }
+      latch.await(MODEL_CHECK_TIMEOUT_MS, TimeUnit.MILLISECONDS)
+    } catch (_: Throwable) {
+      // Leave `ready` as it was; the shared gate's wait decides when to stop.
+    }
+    return ready
+  }
+
+  /** Re-asks Play Services in the background; at most one check at a time. */
+  private fun refresh() {
+    if (checking) return
+    val ctx = NitroModules.applicationContext ?: return
+    checking = true
+    try {
+      ModuleInstall.getClient(ctx).areModulesAvailable(api)
+        .addOnSuccessListener { response -> if (response.areModulesAvailable()) ready = true }
+        .addOnCompleteListener { checking = false }
+    } catch (_: Throwable) {
+      checking = false
+    }
+  }
+
+  private fun requestInstall(client: ModuleInstallClient) {
+    if (installing) return
+    installing = true
+
+    val listener = object : InstallStatusListener {
+      override fun onInstallStatusUpdated(update: ModuleInstallStatusUpdate) {
+        when (update.installState) {
+          ModuleInstallStatusUpdate.InstallState.STATE_COMPLETED -> {
+            ready = true
+            installing = false
+            client.unregisterListener(this)
+          }
+          ModuleInstallStatusUpdate.InstallState.STATE_FAILED,
+          ModuleInstallStatusUpdate.InstallState.STATE_CANCELED -> {
+            // Cleared so the next prepare() can ask again.
+            installing = false
+            client.unregisterListener(this)
+          }
+        }
+      }
+    }
+
+    // `installModules` takes a ModuleInstallRequest; `deferredInstall` takes the
+    // OptionalModuleApi itself. Handing a request to the wrong one is how this
+    // file once stopped compiling.
+    val request = ModuleInstallRequest.Builder().addApi(api).setListener(listener).build()
+    client.installModules(request)
+      .addOnSuccessListener { response ->
+        // The listener never fires for a module that was already there.
+        if (response.areModulesAlreadyInstalled()) {
+          ready = true
+          installing = false
+          client.unregisterListener(listener)
+        }
+      }
+      .addOnFailureListener {
+        installing = false
+        client.unregisterListener(listener)
+      }
+  }
+
+  private companion object {
+    /**
+     * Bound on the availability query. It is a local Play Services call, not the
+     * model download — the download runs in the background afterwards. Generous
+     * enough for a cold Play Services process, short enough that a wedged one
+     * cannot stall flow start.
+     */
+    const val MODEL_CHECK_TIMEOUT_MS = 3_000L
+  }
+}

package/app.plugin.js

@@ -27,8 +27,12 @@ const pkg = require('./package.json');
 // unconditionally would break code-signing for every consumer who does not read
 // chips and has not enabled it.
 //
-// Camera preview/capture itself comes from react-native-vision-camera; add its
-// config plugin too. This one is intentionally minimal and idempotent.
+// Camera preview/capture itself comes from react-native-vision-camera, but v5
+// ships NO config plugin (v4 did), so it must NOT be listed in the host app's
+// `plugins`. Expo then loads the package's main entry as a plugin and prebuild
+// dies on `Cannot find module '.../lib/VisionCamera'`. That is why the camera
+// permission and usage string are declared HERE. This plugin is intentionally
+// minimal and idempotent.
 // ---------------------------------------------------------------------------
 
 const CAMERA_USAGE =
@@ -37,6 +41,9 @@ const CAMERA_USAGE =
 const NFC_USAGE =
   'We read the secure chip in your passport or ID card to confirm the document is genuine.';
 
+const LOCATION_USAGE =
+  'We use your location to confirm you are at the address you pin during verification.';
+
 /**
  * The eMRTD application identifier.
  *
@@ -62,6 +69,23 @@ function withIosCameraUsage(config, customMessage) {
   });
 }
 
+/**
+ * iOS location usage string, for the address-collection step's one-shot fix
+ * ("Use my current location" + the attest-presence claim). Written by DEFAULT
+ * because its ABSENCE is a crash: iOS kills an app that requests location
+ * without a usage string, and whether the step runs is decided by the org's
+ * WORKFLOW, not by anything the host app author can see at build time. An
+ * unused usage string costs nothing. `location: false` opts out.
+ */
+function withIosLocationUsage(config, customMessage) {
+  return withInfoPlist(config, (cfg) => {
+    if (!cfg.modResults.NSLocationWhenInUseUsageDescription) {
+      cfg.modResults.NSLocationWhenInUseUsageDescription = customMessage || LOCATION_USAGE;
+    }
+    return cfg;
+  });
+}
+
 const AID_KEY = 'com.apple.developer.nfc.readersession.iso7816.select-identifiers';
 const FORMATS_KEY = 'com.apple.developer.nfc.readersession.formats';
 
@@ -112,25 +136,135 @@ function withIosNfc(config, customMessage) {
   });
 }
 
-function withAndroidPermissions(config, { nfc }) {
+/**
+ * The Android permission list for a given set of opt-ins. Pure and exported
+ * so the tests can pin what `location: 'always'` declares — a permission
+ * that changes review posture must never arrive by accident.
+ */
+function androidPermissionsFor({ nfc, location, backgroundLocation }) {
+  return [
+    'android.permission.CAMERA',
+    'android.permission.INTERNET',
+    ...(nfc ? ['android.permission.NFC'] : []),
+    // Foreground location, for the address-collection step's one-shot fix.
+    ...(location
+      ? ['android.permission.ACCESS_COARSE_LOCATION', 'android.permission.ACCESS_FINE_LOCATION']
+      : []),
+    // The always-on presence tier (OkHi model, opt-in): OS geofencing needs
+    // the background grant, and Google Play reviews any app that declares
+    // it — which is why this is `location: 'always'` only, never a default.
+    // The foreground-service pair rides the same opt-in: FOREGROUND_SERVICE
+    // is a normal permission, and FOREGROUND_SERVICE_LOCATION (API 34+) is
+    // what lets expo-location's service declare the `location` type; Play
+    // reviews it under the same location declaration.
+    ...(backgroundLocation
+      ? [
+          'android.permission.ACCESS_BACKGROUND_LOCATION',
+          'android.permission.FOREGROUND_SERVICE',
+          'android.permission.FOREGROUND_SERVICE_LOCATION',
+        ]
+      : []),
+  ];
+}
+
+function withAndroidPermissions(config, opts) {
+  return withAndroidManifest(config, (cfg) => {
+    AndroidConfig.Permissions.ensurePermissions(cfg.modResults, androidPermissionsFor(opts));
+    return cfg;
+  });
+}
+
+/**
+ * Declares `android.hardware.nfc` as NOT required, on the host's manifest.
+ *
+ * This is not decoration, and it must never be separated from the NFC
+ * permission. Android INFERS `<uses-feature android:name="android.hardware.nfc"
+ * android:required="true">` from `android.permission.NFC` whenever the feature
+ * is not declared explicitly — and Play then hides the app from every device
+ * without an NFC radio. For a KYC SDK that is most of the catalogue in the
+ * markets we serve.
+ *
+ * So: the permission (androidPermissionsFor) and this declaration are written
+ * under the same `nfc: true` opt-in in withMyazaKyc, and nothing else writes
+ * either. plugin.test.ts pins that pairing with a source scan, because two
+ * separate functions are otherwise free to drift apart.
+ *
+ * Pure and exported so the pairing can be pinned by a test. The failure it
+ * guards has no runtime symptom in development — the app builds, installs and
+ * runs perfectly on the NFC-capable phone the developer is holding, and is
+ * simply absent from the store listing for everyone else.
+ *
+ * @param {Record<string, any>} manifest the `modResults.manifest` object
+ */
+function ensureNfcFeatureOptional(manifest) {
+  const list = Array.isArray(manifest['uses-feature']) ? manifest['uses-feature'] : [];
+  const existing = list.find((f) => f && f.$ && f.$['android:name'] === 'android.hardware.nfc');
+  if (existing) {
+    // An explicit `required="true"` from the host or another library would
+    // reintroduce exactly the store-visibility problem above, so it is
+    // overwritten rather than respected.
+    existing.$['android:required'] = 'false';
+  } else {
+    list.push({
+      $: { 'android:name': 'android.hardware.nfc', 'android:required': 'false' },
+    });
+  }
+  manifest['uses-feature'] = list;
+  return manifest;
+}
+
+function withAndroidNfcFeature(config) {
   return withAndroidManifest(config, (cfg) => {
-    AndroidConfig.Permissions.ensurePermissions(cfg.modResults, [
-      'android.permission.CAMERA',
-      'android.permission.INTERNET',
-      ...(nfc ? ['android.permission.NFC'] : []),
-    ]);
+    ensureNfcFeatureOptional(cfg.modResults.manifest);
+    return cfg;
+  });
+}
+
+/** iOS side of the always-on tier: the Always usage string plus the location
+ *  background mode, without which a geofence wake is refused. */
+function withIosBackgroundLocation(config, customMessage) {
+  return withInfoPlist(config, (cfg) => {
+    if (!cfg.modResults.NSLocationAlwaysAndWhenInUseUsageDescription) {
+      cfg.modResults.NSLocationAlwaysAndWhenInUseUsageDescription =
+        customMessage || LOCATION_USAGE;
+    }
+    const modes = Array.isArray(cfg.modResults.UIBackgroundModes)
+      ? cfg.modResults.UIBackgroundModes
+      : [];
+    if (!modes.includes('location')) modes.push('location');
+    cfg.modResults.UIBackgroundModes = modes;
     return cfg;
   });
 }
 
 /**
  * @param {object} config
- * @param {{ cameraPermission?: string, nfc?: boolean, nfcPermission?: string }} [props]
+ * @param {{ cameraPermission?: string, nfc?: boolean, nfcPermission?: string,
+ *           location?: boolean | 'always', locationPermission?: string }} [props]
  */
 function withMyazaKyc(config, props = {}) {
+  const location = props.location !== false;
+  // `location: 'always'` opts into the background presence tier. Explicit on
+  // purpose: it changes the app's Play/App Store review posture, so it must
+  // never arrive as a side effect of a default.
+  const backgroundLocation = props.location === 'always';
   config = withIosCameraUsage(config, props.cameraPermission);
-  config = withAndroidPermissions(config, { nfc: props.nfc === true });
+  config = withAndroidPermissions(config, {
+    nfc: props.nfc === true,
+    location,
+    backgroundLocation,
+  });
+  if (location) {
+    config = withIosLocationUsage(config, props.locationPermission);
+  }
+  if (backgroundLocation) {
+    config = withIosBackgroundLocation(config, props.locationPermission);
+  }
   if (props.nfc === true) {
+    // Android: the permission comes from androidPermissionsFor above; this adds
+    // the uses-feature that must accompany it. Never write one without the
+    // other — see ensureNfcFeatureOptional.
+    config = withAndroidNfcFeature(config);
     config = withIosNfc(config, props.nfcPermission);
   }
   return config;
@@ -141,4 +275,6 @@ module.exports = createRunOncePlugin(withMyazaKyc, pkg.name, pkg.version);
 // consumers' app.json entries are unaffected.
 module.exports.applyNfcInfoPlist = applyNfcInfoPlist;
 module.exports.applyNfcEntitlements = applyNfcEntitlements;
+module.exports.androidPermissionsFor = androidPermissionsFor;
+module.exports.ensureNfcFeatureOptional = ensureNfcFeatureOptional;
 module.exports.EMRTD_AID = EMRTD_AID;

package/ios/HybridMyazaFaceDetector.swift

@@ -303,8 +303,13 @@ final class HybridMyazaFaceDetector: HybridMyazaFaceDetectorSpec {
     return min(max(v, 0.0), 1.0)
   }
 
-  /// Smile from outer-lip width relative to the face. Input band (0.40→0.50):
-  /// a neutral mouth sits near 0, a clear smile lands well above the threshold.
+  /// Smile from outer-lip width relative to the face box. Input band
+  /// (0.36→0.46): the shared detector passes above 0.5, so the pass line sits
+  /// at a lip width of 0.41 of the box. It was 0.40→0.50 (pass at 0.45), which
+  /// on device needed a full grin — a modest, natural smile never crossed it.
+  /// ML Kit on Android returns a classifier probability instead, so this band
+  /// is the iOS half of one shared threshold: tune it here, not in
+  /// detectSmile, or Android loosens with it.
   private static func smileProbability(_ landmarks: VNFaceLandmarks2D?) -> Double {
     guard let pts = landmarks?.outerLips?.normalizedPoints, pts.count >= 4 else {
       return 0.0
@@ -315,7 +320,7 @@ final class HybridMyazaFaceDetector: HybridMyazaFaceDetectorSpec {
       minX = min(minX, Double(p.x)); maxX = max(maxX, Double(p.x))
     }
     let width = maxX - minX
-    let score = (width - 0.40) / (0.50 - 0.40)
+    let score = (width - 0.36) / (0.46 - 0.36)
     return min(max(score, 0.0), 1.0)
   }
 

package/ios/HybridMyazaTextRecognizer.swift

@@ -27,6 +27,14 @@ import NitroModules
 // ---------------------------------------------------------------------------
 
 final class HybridMyazaTextRecognizer: HybridMyazaTextRecognizerSpec {
+  // Apple Vision ships with the OS — there is no model to fetch, no Play
+  // Services equivalent, and no window in which recognition is unavailable.
+  // These exist only because Android fetches ML Kit's models on demand; iOS
+  // answers "ready" unconditionally so the shared TS flow needs no platform
+  // branch.
+  func isModelReady() throws -> Bool { true }
+
+  func prepareModel() throws -> Promise<Bool> { Promise.resolved(withResult: true) }
 
   func recognizeText(frame: any HybridFrameSpec, bottomFraction: Double) throws -> TextResult {
     guard

package/nitrogen/generated/android/c++/JHybridMyazaTextRecognizerSpec.cpp

@@ -76,5 +76,26 @@ namespace margelo::nitro::myazakyc {
       return __promise;
     }();
   }
+  bool JHybridMyazaTextRecognizerSpec::isModelReady() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isModelReady");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::shared_ptr<Promise<bool>> JHybridMyazaTextRecognizerSpec::prepareModel() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("prepareModel");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::myazakyc

package/nitrogen/generated/android/c++/JHybridMyazaTextRecognizerSpec.hpp

@@ -56,6 +56,8 @@ namespace margelo::nitro::myazakyc {
     // Methods
     TextResult recognizeText(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame, double bottomFraction) override;
     std::shared_ptr<Promise<TextResult>> recognizeTextInImage(const std::string& uri, double bottomFraction) override;
+    bool isModelReady() override;
+    std::shared_ptr<Promise<bool>> prepareModel() override;
 
   private:
     jni::global_ref<JHybridMyazaTextRecognizerSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/myazakyc/HybridMyazaTextRecognizerSpec.kt

@@ -37,6 +37,14 @@ abstract class HybridMyazaTextRecognizerSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun recognizeTextInImage(uri: String, bottomFraction: Double): Promise<TextResult>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun isModelReady(): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun prepareModel(): Promise<Boolean>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/ios/c++/HybridMyazaTextRecognizerSpecSwift.hpp

@@ -90,6 +90,22 @@ namespace margelo::nitro::myazakyc {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool isModelReady() override {
+      auto __result = _swiftPart.isModelReady();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> prepareModel() override {
+      auto __result = _swiftPart.prepareModel();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     KycSdkReactNative::HybridMyazaTextRecognizerSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridMyazaTextRecognizerSpec.swift

@@ -16,6 +16,8 @@ public protocol HybridMyazaTextRecognizerSpec_protocol: HybridObject {
   // Methods
   func recognizeText(frame: (any HybridFrameSpec), bottomFraction: Double) throws -> TextResult
   func recognizeTextInImage(uri: String, bottomFraction: Double) throws -> Promise<TextResult>
+  func isModelReady() throws -> Bool
+  func prepareModel() throws -> Promise<Bool>
 }
 
 public extension HybridMyazaTextRecognizerSpec_protocol {

package/nitrogen/generated/ios/swift/HybridMyazaTextRecognizerSpec_cxx.swift

@@ -159,4 +159,35 @@ open class HybridMyazaTextRecognizerSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_TextResult___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func isModelReady() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.isModelReady()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func prepareModel() -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.prepareModel()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/shared/c++/HybridMyazaTextRecognizerSpec.cpp

@@ -16,6 +16,8 @@ namespace margelo::nitro::myazakyc {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("recognizeText", &HybridMyazaTextRecognizerSpec::recognizeText);
       prototype.registerHybridMethod("recognizeTextInImage", &HybridMyazaTextRecognizerSpec::recognizeTextInImage);
+      prototype.registerHybridMethod("isModelReady", &HybridMyazaTextRecognizerSpec::isModelReady);
+      prototype.registerHybridMethod("prepareModel", &HybridMyazaTextRecognizerSpec::prepareModel);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridMyazaTextRecognizerSpec.hpp

@@ -57,6 +57,8 @@ namespace margelo::nitro::myazakyc {
       // Methods
       virtual TextResult recognizeText(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame, double bottomFraction) = 0;
       virtual std::shared_ptr<Promise<TextResult>> recognizeTextInImage(const std::string& uri, double bottomFraction) = 0;
+      virtual bool isModelReady() = 0;
+      virtual std::shared_ptr<Promise<bool>> prepareModel() = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myazahq/kyc-sdk-react-native",
-  "version": "2.5.0",
+  "version": "3.0.0",
   "description": "Myaza KYC SDK for React Native (Expo) — ID verification, liveness detection, and document capture",
   "author": "Flitstack Technologies Inc.",
   "repository": {
@@ -49,6 +49,12 @@
   "license": "MIT",
   "peerDependencies": {
     "expo": ">=56",
+    "expo-application": ">=56",
+    "expo-device": ">=56",
+    "expo-document-picker": ">=56",
+    "expo-localization": ">=56",
+    "expo-task-manager": ">=14",
+    "react-native-webview": ">=13",
     "react": ">=19",
     "react-native": ">=0.83",
     "react-native-nitro-image": ">=0.15",
@@ -58,27 +64,42 @@
     "react-native-vision-camera-worklets": ">=5",
     "react-native-worklets": ">=0.8"
   },
+  "peerDependenciesMeta": {
+    "expo-application": {
+      "optional": true
+    },
+    "expo-device": {
+      "optional": true
+    },
+    "expo-document-picker": {
+      "optional": true
+    },
+    "expo-localization": {
+      "optional": true
+    },
+    "expo-task-manager": {
+      "optional": true
+    },
+    "react-native-webview": {
+      "optional": true
+    }
+  },
   "dependencies": {
-    "@expo-google-fonts/karla": "^0.4.2",
-    "@expo-google-fonts/space-grotesk": "^0.4.1",
-    "@expo/vector-icons": "^14.0.4",
     "country-flag-icons": "^1.6.17",
-    "expo-application": "~56.0.3",
     "libphonenumber-js": "^1.13.8",
     "expo-crypto": "~56.0.4",
     "expo-clipboard": "~56.0.0",
-    "expo-device": "~56.0.4",
-    "expo-document-picker": "~56.0.4",
     "expo-font": "~56.0.5",
     "expo-glass-effect": "~56.0.4",
     "expo-image-manipulator": "~56.0.17",
     "expo-image-picker": "~56.0.16",
-    "expo-localization": "~56.0.6",
+    "expo-location": "~56.0.24",
     "expo-speech": "~56.0.3",
     "lucide-react-native": "^1.17.0",
     "react-native-compressor": "^1.19.0",
     "react-native-vision-camera": "^5.0.11",
-    "zustand": "^5.0.2"
+    "zustand": "^5.0.2",
+    "expo-file-system": "~56.0.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",

package/src/MyazaKYC.tsx

@@ -15,8 +15,8 @@ import type { KYCStep, MyazaKYCConfig, SupportedCountry } from './types/config';
 import { KycRuntimeProvider, MyazaThemeProvider } from './components/runtime';
 import { WorkflowGate } from './components/WorkflowGate';
 import { useWorkflowMount } from './components/useWorkflowMount';
+import { usePrimeModels } from './lib/prime-models';
 import { safeReportError } from './services/errors';
-import { primeFaceModel } from './liveness/visionCameraFaceDetector';
 import { KycFlow, type BackResult } from './components/KycFlow';
 import { MyazaButton } from './components/MyazaButton';
 
@@ -99,16 +99,7 @@ function MyazaKYCTrigger({
   const settled = state.status !== 'resolving';
   const open = wantOpen && settled;
 
-  // Start fetching the face model the moment the user opens the flow, so the
-  // download overlaps consent and ID-type selection rather than stalling in
-  // front of the camera. Mirrors the web SDK's primeFaceMesh() on mount; the
-  // liveness step still gates on isFaceModelReady(), so this is best-effort.
-  const primedRef = useRef(false);
-  useEffect(() => {
-    if (!wantOpen || primedRef.current) return;
-    primedRef.current = true;
-    primeFaceModel();
-  }, [wantOpen]);
+  usePrimeModels(wantOpen, config.apiKey, config.devUrl);
 
   // Reported only once the user has actually tried to start. Prefetching must
   // not fire a consumer's error handler for a flow they never opened.
@@ -229,6 +220,8 @@ export function useMyazaKYC<C extends SupportedCountry = SupportedCountry>(
   configRef.current = config;
   const backRef = useRef<(() => BackResult) | null>(null);
 
+  usePrimeModels(wantOpen, config.apiKey, config.devUrl);
+
   // `refresh` is defined further down (it needs `wrappedConfig`), so it is
   // reached through a ref rather than reordering the component around it.
   const refreshRef = useRef<() => void>(() => undefined);