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

package/src/screens/document/CaptureCheckNotice.tsx

@@ -0,0 +1,77 @@
+import React from 'react';
+import { View } from 'react-native';
+
+import { spacing } from '../../config/theme';
+import { MyazaAlert } from '../../components/MyazaAlert';
+import { MyazaButton } from '../../components/MyazaButton';
+import { documentReviewCopy } from '../../components/documentReviewCopy';
+import {
+  CAPTURE_CHECK_CONTINUE_ANYWAY,
+  CAPTURE_CHECK_TITLE,
+  captureProblemMessage,
+  captureRetakeLabel,
+  captureRetakeSides,
+  type CaptureProblem,
+} from '../../lib/documentCaptureCheck';
+import type { DocumentCaptureSide } from '../../services/api-types';
+
+// ─── The review footer when a document photo will not read ───────────────────
+//
+// Shown in place of Continue after the server's capture check found no face on
+// the printed photo or no readable barcode (lib/documentCaptureCheck). The
+// words come from that module so they stay in lockstep with the web and
+// Flutter SDKs.
+//
+// A notice, never a gate: the detectors can miss, so "Continue anyway" is
+// always offered and moves on with the photos already uploaded. The first
+// retake is the primary action because a retake is the likelier fix.
+
+export function CaptureCheckNotice({
+  problems,
+  uploadOnly,
+  onRetake,
+  onContinueAnyway,
+}: {
+  problems: readonly CaptureProblem[];
+  /** The sides were picked from the device, so they are replaced, not retaken. */
+  uploadOnly: boolean;
+  onRetake: (side: DocumentCaptureSide) => void;
+  onContinueAnyway: () => void;
+}): React.ReactElement {
+  // Once per kind: two sides with the same problem need one sentence, not two.
+  const messages = [...new Set(problems.map((p) => captureProblemMessage(p.kind)))];
+  const sides = captureRetakeSides(problems);
+  const copy = documentReviewCopy(uploadOnly ? 'upload' : 'scan', true);
+
+  return (
+    <View style={{ gap: spacing.sm }}>
+      {/* Grouped and announced: the notice replaces the button the applicant
+          just pressed, so a screen reader has to say why nothing moved on. */}
+      <View
+        accessible
+        accessibilityRole="alert"
+        accessibilityLiveRegion="polite"
+        accessibilityLabel={`${CAPTURE_CHECK_TITLE}. ${messages.join(' ')}`}
+      >
+        <MyazaAlert variant="warning" title={CAPTURE_CHECK_TITLE} message={messages.join('\n\n')} />
+      </View>
+      {sides.map((side, i) => (
+        <MyazaButton
+          key={side}
+          label={captureRetakeLabel(side, uploadOnly)}
+          variant={i === 0 ? 'primary' : 'outline'}
+          leadingIcon="refresh"
+          accessibilityLabel={copy.redoAccessibility(side === 'front' ? 'Front' : 'Back')}
+          onPress={() => onRetake(side)}
+        />
+      ))}
+      <MyazaButton
+        label={CAPTURE_CHECK_CONTINUE_ANYWAY}
+        variant="outline"
+        accessibilityLabel={CAPTURE_CHECK_CONTINUE_ANYWAY}
+        accessibilityHint="Carries on with these photos as they are"
+        onPress={onContinueAnyway}
+      />
+    </View>
+  );
+}

package/src/screens/document/UploadPhase.tsx

@@ -0,0 +1,177 @@
+import React from 'react';
+import { ActivityIndicator, Pressable, View } from 'react-native';
+
+import { radius, spacing } from '../../config/theme';
+import { useTheme } from '../../components/runtime';
+import { MyazaText } from '../../components/Typography';
+import { Icon, type IconName } from '../../components/Icon';
+import { DashedBorder } from '../../components/DashedBorder';
+import type { DocumentCapturePhase } from '../../store/state';
+import { RequiredPill } from './RequiredPill';
+
+// ─── Document capture without the camera ──────────────────────────────────────
+//
+// One side of the document when the workflow switches scanning off
+// (`allowDocumentScan: false`): a photo chosen from the device, never a camera
+// shot. It renders in place of the camera gates, and nothing here touches
+// VisionCamera, so an upload-only flow never asks for camera access and never
+// records a capture video.
+//
+// Only the ASK differs. What happens after the pick is the step's own and shared
+// with the camera path: the interactive cropper, the compress, the MRZ read off
+// the front, the front preview and the review.
+
+/** The sheet header for an upload-only capture phase (see documentCaptureMeta). */
+export function documentUploadMeta(
+  phase: DocumentCapturePhase,
+  documentLabel: string,
+): { title: string; description: string } {
+  switch (phase) {
+    case 'front':
+      return {
+        title: `Upload Your ${documentLabel}`,
+        description: `Choose a clear photo of your ${documentLabel} from your device.`,
+      };
+    case 'front-preview':
+      return {
+        title: 'Front Side Added',
+        description: 'Looks good? Tap Next to add a photo of the back.',
+      };
+    case 'back':
+      return {
+        title: 'Upload Back Side',
+        description: `Now choose a photo of the back of your ${documentLabel}.`,
+      };
+    case 'review':
+    default:
+      return {
+        title: `Review Your ${documentLabel}`,
+        description: 'Tap Continue to upload and submit your document.',
+      };
+  }
+}
+
+const TIPS: ReadonlyArray<{ icon: IconName; label: string }> = [
+  { icon: 'id-card', label: 'The whole document in view, all four corners' },
+  { icon: 'sun', label: 'Sharp and evenly lit, with no glare' },
+];
+
+export interface UploadPhaseProps {
+  isBack: boolean;
+  documentLabel: string;
+  isTwoSided: boolean;
+  /** A picked photo is being cropped and compressed. */
+  busy: boolean;
+  onUpload: () => void;
+}
+
+export function UploadPhase(p: UploadPhaseProps): React.ReactElement {
+  const { colors } = useTheme();
+  const subject = !p.isTwoSided ? `your ${p.documentLabel}` : p.isBack ? 'the back' : 'the front';
+  const ask = `Add a photo of ${subject}`;
+  const choose = () => {
+    if (!p.busy) p.onUpload();
+  };
+
+  return (
+    <View>
+      <RequiredPill
+        documentLabel={p.documentLabel}
+        sideBadge={p.isTwoSided ? (p.isBack ? 'Back Side' : 'Front Side') : undefined}
+        stepLabel={p.isTwoSided ? (p.isBack ? 'Step 2 of 2' : 'Step 1 of 2') : undefined}
+      />
+      {p.isBack ? (
+        <View style={{ flexDirection: 'row', alignItems: 'center', marginTop: spacing.sm, marginBottom: spacing.xs }}>
+          <Icon name="credit-card" size={14} color={colors.primary} />
+          <View style={{ width: 4 }} />
+          <MyazaText variant="bodySmall" color={colors.primary} style={{ fontWeight: '500' }}>
+            Turn the card over and add a photo of the other side
+          </MyazaText>
+        </View>
+      ) : null}
+      <View style={{ height: spacing.md }} />
+
+      {/* The whole card is the target and there is no button beside it: on a
+          screen whose only job is to open the photo picker, the card is where
+          the thumb goes. A press deepens the fill and solidifies the border;
+          the primary line at the bottom says what a tap does. */}
+      <Pressable
+        testID={`kyc.document.upload.${p.isBack ? 'back' : 'front'}`}
+        onPress={choose}
+        disabled={p.busy}
+        accessibilityRole="button"
+        accessibilityLabel={p.busy ? 'Preparing your photo' : ask}
+        accessibilityHint="Opens your photos"
+        accessibilityState={{ busy: p.busy, disabled: p.busy }}
+        style={({ pressed }) => ({
+          alignItems: 'center',
+          paddingVertical: spacing.xl,
+          paddingHorizontal: spacing.lg,
+          borderRadius: radius.md,
+          backgroundColor: pressed ? `${colors.primary}1A` : `${colors.primary}0D`,
+          transform: [{ scale: pressed ? 0.99 : 1 }],
+        })}
+      >
+        {({ pressed }) => (
+          <>
+            <DashedBorder
+              color={pressed ? colors.primary : `${colors.primary}66`}
+              radius={radius.md}
+              strokeWidth={1.5}
+            />
+            <View
+              style={{
+                width: 64,
+                height: 64,
+                borderRadius: radius.full,
+                backgroundColor: `${colors.primary}1A`,
+                alignItems: 'center',
+                justifyContent: 'center',
+              }}
+            >
+              {p.busy ? (
+                <ActivityIndicator size="small" color={colors.primary} />
+              ) : (
+                <Icon name="image" size={30} color={colors.primary} />
+              )}
+            </View>
+            <View style={{ height: spacing.md }} />
+            <MyazaText variant="heading3" style={{ textAlign: 'center' }}>
+              {p.busy ? 'Preparing your photo…' : ask}
+            </MyazaText>
+            <View style={{ height: spacing.xs }} />
+            <MyazaText variant="bodySmall" color={colors.textSecondary} style={{ textAlign: 'center' }}>
+              Choose a clear photo from your device. You can crop it on the next screen.
+            </MyazaText>
+            <View style={{ height: spacing.md }} />
+            {/* Stays in the layout while busy so the card keeps its height. */}
+            <View
+              style={{ flexDirection: 'row', alignItems: 'center', opacity: p.busy ? 0 : 1 }}
+              accessibilityElementsHidden
+              importantForAccessibility="no-hide-descendants"
+            >
+              <Icon name="upload" size={16} color={colors.primary} />
+              <View style={{ width: spacing.xs }} />
+              <MyazaText variant="label" color={colors.primary} style={{ fontWeight: '600' }}>
+                Tap to choose a photo
+              </MyazaText>
+              <View style={{ width: 2 }} />
+              <Icon name="chevron-right" size={16} color={colors.primary} />
+            </View>
+          </>
+        )}
+      </Pressable>
+
+      <View style={{ height: spacing.md }} />
+      {TIPS.map((tip) => (
+        <View key={tip.label} style={{ flexDirection: 'row', alignItems: 'center', marginBottom: spacing.xs }}>
+          <Icon name={tip.icon} size={16} color={colors.textMuted} />
+          <View style={{ width: spacing.sm }} />
+          <MyazaText variant="bodySmall" color={colors.textSecondary} style={{ flexShrink: 1 }}>
+            {tip.label}
+          </MyazaText>
+        </View>
+      ))}
+    </View>
+  );
+}

package/src/screens/document/useDocumentCamera.ts

@@ -0,0 +1,109 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useCameraDevice, useCameraPermission } from 'react-native-vision-camera';
+
+import { safeReportError } from '../../services/errors';
+import { KYCError } from '../../types/verification';
+
+// The document camera's permission and hardware state, lifted out of
+// DocumentCaptureStep so that only a workflow which SCANS ever calls
+// VisionCamera's hooks. An upload-only workflow (`allowDocumentScan: false`)
+// never mounts the component that uses this, so it never reads the camera
+// permission, never enumerates devices and never prompts. The logic is the
+// step's own, moved rather than changed.
+
+export type DocumentCameraPermission = 'priming' | 'requesting' | 'granted' | 'denied';
+
+export interface DocumentCamera {
+  perm: DocumentCameraPermission;
+  /** A back camera exists (false on a simulator, which has none). */
+  hasDevice: boolean;
+  /** No camera hardware at all, once the device list has had a moment. */
+  cameraUnavailable: boolean;
+  /** The "Allow camera access" primer, shown before the OS prompt. */
+  showPrimer: boolean;
+  /** A real camera exists but the OS blocked access. */
+  permissionDenied: boolean;
+  /** Fire the real OS prompt: the primer's "Grant access", or a retry. */
+  requestAccess: () => void;
+}
+
+export function useDocumentCamera(onError: ((error: KYCError) => void) | undefined): DocumentCamera {
+  // ── Camera permission ──────────────────────────────────────────────────────
+  // `perm` is derived from the ASYNC requestPermission result, not synchronously
+  // from `hasPermission` — otherwise the brief window while the OS prompt is open
+  // (hasPermission still false) would read as "denied" and fire onError early.
+  // 'priming' shows the "Allow camera access" screen BEFORE the OS prompt
+  // (Stripe-style); the prompt only fires (→ 'requesting') once the user taps
+  // "Grant access".
+  const { hasPermission, requestPermission } = useCameraPermission();
+  const [perm, setPerm] = useState<DocumentCameraPermission>(hasPermission ? 'granted' : 'priming');
+  const permReportedRef = useRef(false);
+
+  // ── Camera availability ─────────────────────────────────────────────────────
+  // Even with permission granted, there may be no usable back camera (the iOS/
+  // Android simulator has none; a real device may fail to init). Give the device
+  // list a moment to resolve, then surface a proper "Camera not available" error
+  // with an upload fallback — on every iOS version (glass or not) and Android.
+  // Device enumeration does NOT need camera permission (iOS AVCaptureDevice /
+  // Android CameraManager list hardware regardless), so `!device` reliably means
+  // "no back-camera hardware" — true on every simulator. That's a different state
+  // from "permission denied": no hardware → nothing to grant.
+  const device = useCameraDevice('back');
+  const [cameraGrace, setCameraGrace] = useState(false);
+  useEffect(() => {
+    const t = setTimeout(() => setCameraGrace(true), 1500);
+    return () => clearTimeout(t);
+  }, []);
+  // No camera hardware at all → "Camera not available" (regardless of what the
+  // permission API says — on a camera-less sim it may even report denied).
+  const cameraUnavailable = cameraGrace && !device;
+
+  // Reflect an externally-granted permission.
+  useEffect(() => {
+    if (hasPermission) setPerm('granted');
+  }, [hasPermission]);
+
+  // Fire the real OS prompt only after the user taps "Grant access" (or retry).
+  useEffect(() => {
+    if (perm !== 'requesting') return;
+    let cancelled = false;
+    void (async () => {
+      const granted = await requestPermission();
+      if (!cancelled) setPerm(granted ? 'granted' : 'denied');
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [perm, requestPermission]);
+
+  // A *genuine* permission denial requires a camera to exist but be blocked. On a
+  // camera-less sim the OS may report denied — that's "not available", not a
+  // permission problem, so don't treat it as denied or report onError there.
+  const permissionDenied = perm === 'denied' && !!device;
+  useEffect(() => {
+    if (permissionDenied && !permReportedRef.current) {
+      permReportedRef.current = true;
+      safeReportError(
+        onError,
+        new KYCError(
+          'camera_permission_denied',
+          'Camera access is required to photograph your document. Allow camera access or upload a photo instead.',
+        ),
+      );
+    }
+    if (!permissionDenied) permReportedRef.current = false;
+  }, [permissionDenied, onError]);
+
+  const requestAccess = useCallback(() => {
+    setPerm('requesting');
+  }, []);
+
+  return {
+    perm,
+    hasDevice: !!device,
+    cameraUnavailable,
+    showPrimer: perm === 'priming' && !!device,
+    permissionDenied,
+    requestAccess,
+  };
+}

package/src/screens/liveness/LivenessOutcome.tsx

@@ -23,12 +23,15 @@ import type { LivenessFailureReason } from '../../liveness/types';
 
 export function LivenessComplete({
   selfieUri,
+  soft = false,
   upload,
   onRetake,
   onContinue,
 }: {
   /** Null on a restored session: the mediaId survived, the local file did not. */
   selfieUri: string | null;
+  /** The still reads out of focus. A notice on the preview, never a gate. */
+  soft?: boolean;
   upload: SelfieUpload;
   onRetake: () => void;
   onContinue: () => void;
@@ -38,7 +41,7 @@ export function LivenessComplete({
     upload;
   return (
       <View>
-        <SelfiePreview uri={selfieUri} uploading={uploading && !uploadError} />
+        <SelfiePreview uri={selfieUri} uploading={uploading && !uploadError} soft={soft} />
         {retryInfo && uploading ? (
           <MyazaText variant="bodySmall" color={colors.warning} style={{ textAlign: 'center', marginTop: spacing.sm }}>
             {`Upload failed, retrying (${retryInfo.attempt}/${retryInfo.total})`}

package/src/screens/liveness/SelfiePreview.tsx

@@ -11,7 +11,16 @@ import { StyleAbsFill } from './constants';
 // The captured selfie, shown back while it uploads.
 // ---------------------------------------------------------------------------
 
-export function SelfiePreview({ uri, uploading }: { uri: string | null; uploading?: boolean }): React.ReactElement {
+export function SelfiePreview({
+  uri,
+  uploading,
+  soft = false,
+}: {
+  uri: string | null;
+  uploading?: boolean;
+  /** The still reads out of focus (lib/selfie-sharpness). */
+  soft?: boolean;
+}): React.ReactElement {
   const { colors } = useTheme();
   const S = 200;
   return (
@@ -37,11 +46,17 @@ export function SelfiePreview({ uri, uploading }: { uri: string | null; uploadin
         ) : null}
       </View>
       <View style={{ height: spacing.md }} />
-      <MyazaText variant="heading3" style={{ textAlign: 'center' }}>
-        Looking good!
+      {/* The heading is the review's verdict on the photo, so a soft still must
+          not read "Looking good!". Continue stays available either way: the
+          floor is uncalibrated, and a wrong one should cost a sentence, never
+          a retake loop. */}
+      <MyazaText variant="heading3" color={soft ? colors.warning : undefined} style={{ textAlign: 'center' }}>
+        {soft ? 'This photo looks blurry' : 'Looking good!'}
       </MyazaText>
       <MyazaText variant="bodySmall" color={colors.textSecondary} style={{ textAlign: 'center' }}>
-        Tap Continue to submit, or Retake to try again.
+        {soft
+          ? 'For the best chance of a match, retake it holding the phone steady until your face is sharp.'
+          : 'Tap Continue to submit, or Retake to try again.'}
       </MyazaText>
     </View>
   );

package/src/services/api-types.ts

@@ -43,6 +43,34 @@ export interface UploadResponse {
   mediaId: string;
 }
 
+/** Which side of a document a capture check is about. */
+export type DocumentCaptureSide = 'front' | 'back';
+
+/**
+ * Ask whether an uploaded document photo will be readable, using the same
+ * detectors the server later decides the verification with.
+ */
+export interface DocumentCaptureCheckRequest {
+  mediaId: string;
+  side: DocumentCaptureSide;
+  country: string;
+  idType: string;
+  /** The workflow the submission will carry, when it carries one. */
+  workflowId?: string;
+  /** The attempt session from /session/start, when the flow has one. */
+  sessionId?: string;
+}
+
+/**
+ * `false` = looked and found nothing (ask for a retake); `true` = fine;
+ * `null` = not applicable, or the server could not look (treat as fine).
+ */
+export interface DocumentCaptureCheckResponse {
+  side: DocumentCaptureSide;
+  face: boolean | null;
+  barcode: boolean | null;
+}
+
 export interface KeyPersonInvite {
   keyPersonId: string;
   name: string;
@@ -408,5 +436,3 @@ export interface BusinessSearchResponse {
 export interface BusinessRegionsResponse {
   regions: { code: string; name: string }[];
 }
-
-export * from './api-types-biometric';

package/src/services/api.ts

@@ -6,6 +6,8 @@ import type {
   BusinessSearchResponse,
   BusinessSelectResponse,
   ContactCheckResponse,
+  DocumentCaptureCheckRequest,
+  DocumentCaptureCheckResponse,
   NfcChallengeResponse,
   ContactSendResponse,
   HealthResponse,
@@ -22,7 +24,6 @@ import type {
   VerifyResponse,
   WorkflowResolutionResponse,
 } from './api-types';
-import { biometricCalls } from './api-biometric';
 
 // The HTTP contract lives in ./api-types and is re-exported here, so importers
 // keep a single entry point for both the client and the shapes it exchanges.
@@ -167,8 +168,6 @@ export function createKYCApi(baseUrl: string, apiKey: string) {
   }
 
   return {
-    ...biometricCalls(request),
-
     /**
      * Single multipart upload: the local file is POSTed to our server, which
      * stores it and returns the `mediaId` referenced later by /verify.
@@ -209,6 +208,23 @@ export function createKYCApi(baseUrl: string, apiKey: string) {
       return mediaId;
     },
 
+    /**
+     * Ask whether an uploaded document side will be readable: a face on the
+     * printed photo, a barcode that decodes. Best-effort by contract at the
+     * call site (lib/documentCaptureCheck runCaptureChecks): a failure or a
+     * timeout reads as "no problem" and never blocks the flow.
+     */
+    async checkDocumentCapture(
+      body: DocumentCaptureCheckRequest,
+      signal?: AbortSignal,
+    ): Promise<DocumentCaptureCheckResponse> {
+      return request<DocumentCaptureCheckResponse>('/document-capture/check', {
+        method: 'POST',
+        body: JSON.stringify(body),
+        ...(signal ? { signal } : {}),
+      });
+    },
+
     async verify(body: VerifyRequest): Promise<VerifyResponse> {
       return request<VerifyResponse>('/verify', {
         method: 'POST',

package/src/services/deviceMetadata.ts

@@ -15,7 +15,7 @@ export type DeviceType = 'mobile' | 'tablet' | 'desktop' | 'unknown';
  * Single source of truth for the SDK version — also used by `services/api.ts`
  * for the `X-SDK-Version` header. Keep in sync with `package.json`.
  */
-export const SDK_VERSION = '2.6.0';
+export const SDK_VERSION = '3.0.0';
 
 export interface ReactNativeDeviceMetadata {
   sdkType: 'react-native';

package/src/services/mediaCompress.ts

@@ -1,4 +1,3 @@
-import { Image } from 'react-native';
 import * as ImageManipulator from 'expo-image-manipulator';
 import { Video } from 'react-native-compressor';
 
@@ -41,10 +40,29 @@ export async function compressVideo(uri: string): Promise<string> {
 //   • SELFIE   — moderate: JPEG q0.8, capped to ~1280 px.
 // Runs natively via expo-image-manipulator (off the JS thread).
 
-export function imageSize(uri: string): Promise<{ width: number; height: number }> {
-  return new Promise((resolve, reject) =>
-    Image.getSize(uri, (width, height) => resolve({ width, height }), reject),
-  );
+/**
+ * The image's TRUE pixel dimensions.
+ *
+ * Measured through expo-image-manipulator — the same native module that does
+ * the cropping — because the two must agree, and they did not.
+ *
+ * This used `Image.getSize`, which on Android reports DP (pixels ÷ display
+ * density), while ImageManipulator crops in real pixels. On a density-2 phone
+ * a 3048x4064 photo measured 1524x2032, so a crop rect computed as "centred"
+ * was applied at half scale and landed in the UPPER-LEFT QUADRANT of the real
+ * image. Every Android document capture cropped the wrong region — the card
+ * the applicant framed was simply not in the stored photo. iOS was unaffected
+ * (getSize returns pixels there), which is how an iPhone-led test history
+ * never saw it. Found on a TECNO KM5 (density 320 → scale 2.0), 2026-09-20:
+ * reported 1524x2032 against a true 3048x4064, a factor of exactly 2.
+ *
+ * Correcting by `PixelRatio.get()` would also work on today's devices, but it
+ * re-states the cropper's units somewhere else and leaves the same class of
+ * bug one refactor away. Asking the cropper itself cannot drift from it.
+ */
+export async function imageSize(uri: string): Promise<{ width: number; height: number }> {
+  const ref = await ImageManipulator.ImageManipulator.manipulate(uri).renderAsync();
+  return { width: ref.width, height: ref.height };
 }
 
 /**

package/src/specs/MyazaTextRecognizer.nitro.ts

@@ -45,4 +45,33 @@ export interface MyazaTextRecognizer extends HybridObject<{ ios: 'swift'; androi
    * crop as the frame version.
    */
   recognizeTextInImage(uri: string, bottomFraction: number): Promise<TextResult>;
+
+  /**
+   * Whether the recogniser can run RIGHT NOW.
+   *
+   * Android fetches ML Kit's text model through Google Play Services rather
+   * than bundling it (see android/build.gradle), so there is a window — first
+   * launch, or a device with no GMS at all — where recognition cannot work.
+   * This MUST be checked before the camera opens: `recognizeText` can only
+   * answer in `TextResult`, where "model missing" and "no text in frame" are
+   * both an empty `lines` array, so relying on it would leave auto-capture
+   * silently never firing and the MRZ never producing a chip key, with nothing
+   * shown to explain why.
+   *
+   * iOS is always true — Apple Vision is a system framework with nothing to
+   * fetch.
+   */
+  isModelReady(): boolean;
+
+  /**
+   * Ask Play Services to download the model, resolving `true` once it is usable
+   * and `false` if it cannot be obtained (no GMS, no network, user declined).
+   *
+   * Call this EARLY — the SDK primes it at flow start, so the download overlaps
+   * the consent and ID-type screens and the model is warm by the time the
+   * document step runs.
+   *
+   * Safe to call repeatedly; resolves immediately when already ready.
+   */
+  prepareModel(): Promise<boolean>;
 }

package/src/store/kycStore.ts

@@ -62,6 +62,7 @@ import { IDLE_SELFIE_UPLOAD } from '../lib/selfie-upload-wait';
 import { resetBusinessCheck, runBusinessCheck } from './businessCheck';
 import { startAttemptSession, watchSessionProgress } from './session';
 import { applicantMediaCaptured, buildApplicantVerifyRequest } from './submitApplicant';
+import { keptIdType } from '../lib/resubmit';
 
 export * from './state';
 export {
@@ -102,7 +103,10 @@ export function createKycStore(
       businessCheck: { ...EMPTY_BUSINESS_CHECK },
       selectedCountry: null,
       countryAutoPicked: false,
-      selectedIdType: null,
+      // A send-back that did not ask for the ID keeps the original one: the
+      // ID steps are narrowed out, so the kept ID is selected here instead.
+      // A restored session only overwrites it with a saved pick.
+      selectedIdType: keptIdType(config.resubmit) as KycState['selectedIdType'],
       idNumber: null,
       multiIdSlotIndex: 0,
       multiIdSlots: [],
@@ -661,7 +665,9 @@ export function createKycStore(
           currentStep: opening,
           selectedCountry: null,
           countryAutoPicked: false,
-          selectedIdType: null,
+          // Same kept ID as at creation: the narrowed flow has no picker to
+          // choose it again.
+          selectedIdType: keptIdType(config.resubmit) as KycState['selectedIdType'],
           idNumber: null,
           multiIdSlotIndex: 0,
           multiIdSlots: [],

package/src/types/config.ts

@@ -142,6 +142,12 @@ export interface MyazaKYCConfig<C extends SupportedCountry = SupportedCountry> {
      * mirroring the web SDK.
      */
     businessName?: string;
+    /**
+     * The applicant's email, when you already hold it. Not asked for in the flow:
+     * it is submitted so your organisation can have the applicant emailed about a
+     * decision, for example once their verification is approved.
+     */
+    email?: string;
   };
 
   /** Enable the live-selfie capture step. */
@@ -157,6 +163,15 @@ export interface MyazaKYCConfig<C extends SupportedCountry = SupportedCountry> {
    */
   allowDocumentUpload?: boolean;
 
+  /**
+   * Allow photographing the document with the live camera. Default `true`.
+   * When `false`, the document step never asks for camera access: the
+   * applicant chooses a photo of each side from the device instead. At least
+   * one of this and `allowDocumentUpload` stays on, so a config that switches
+   * both off keeps the camera.
+   */
+  allowDocumentScan?: boolean;
+
   /** Enable liveness detection during selfie capture. Default `true`. */
   enableLiveness?: boolean;