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

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/CaptureRing.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useRef } from 'react';
-import Svg, { Circle } from 'react-native-svg';
+import Svg, { Circle, G } from 'react-native-svg';
 import { advanceTarget, easeToward, mixHex } from '../../lib/captureRing';
 
 // A single line traced around the camera circle's edge for the length of the
@@ -69,23 +69,37 @@ export function CaptureRing({
       style={{ position: 'absolute', top: 0, left: 0 }}
       width={size}
       height={size}
-      // Static origin, not motion: the arc starts at twelve o'clock.
-      rotation={-90}
-      originX={size / 2}
-      originY={size / 2}
     >
-      <Circle
-        ref={ref}
-        cx={size / 2}
-        cy={size / 2}
-        r={r}
-        fill="none"
-        stroke={color}
-        strokeWidth={STROKE}
-        strokeLinecap="butt"
-        strokeDasharray={[circumference]}
-        strokeDashoffset={circumference}
-      />
+      {/* Static origin, not motion: the arc starts AND closes at twelve
+          o'clock, matching Flutter's `drawArc(rect, -pi / 2, ...)`.
+
+          The rotation sits on a <G>, not on the root <Svg>. react-native-svg
+          silently drops transform props on the root: its render applies a
+          transform only `if (transform)` — a `rotation`/`originX`/`originY`
+          triple leaves that undefined, so the branch never runs — and the
+          inner group it wraps children in is built from style/fill/stroke
+          props alone, so nothing forwards them there either. `SvgProps
+          extends GProps`, so the compiler accepts it and the arc quietly
+          starts at three o'clock, which is where the web SDK's CSS
+          `-rotate-90` would have put it had CSS applied here.
+
+          It is also deliberately not on the <Circle>: that node takes a
+          setNativeProps write every frame, and the transform has no business
+          sharing a node with the animation. */}
+      <G rotation={-90} originX={size / 2} originY={size / 2}>
+        <Circle
+          ref={ref}
+          cx={size / 2}
+          cy={size / 2}
+          r={r}
+          fill="none"
+          stroke={color}
+          strokeWidth={STROKE}
+          strokeLinecap="butt"
+          strokeDasharray={[circumference]}
+          strokeDashoffset={circumference}
+        />
+      </G>
     </Svg>
   );
 }

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/screens/supportingDocumentParts.tsx

@@ -0,0 +1,126 @@
+import React from 'react';
+import { View } from 'react-native';
+
+import { radius, spacing } from '../config/theme';
+import { useTheme } from '../components/runtime';
+import { MyazaText } from '../components/Typography';
+import { Icon } from '../components/Icon';
+
+// ---------------------------------------------------------------------------
+// The pieces of a supporting-document card.
+//
+// Split out of the card itself only for the file-length rule; they are that
+// card's own furniture and nothing else builds them. The Flutter SDK splits
+// the same three into supporting_document_parts.dart, for the same reason.
+// ---------------------------------------------------------------------------
+
+const MARKER = 28;
+
+/** A count while the document is outstanding, and a state anybody can read once
+ *  it is not. One document needs no number, so it wears a document glyph. */
+export function DocumentMarker({
+  done,
+  position,
+  total,
+}: {
+  done: boolean;
+  position: number;
+  total: number;
+}): React.ReactElement {
+  const { colors } = useTheme();
+  return (
+    <View
+      style={{
+        width: MARKER,
+        height: MARKER,
+        borderRadius: radius.full,
+        alignItems: 'center',
+        justifyContent: 'center',
+        backgroundColor: done ? colors.primary : colors.primary100,
+      }}
+    >
+      {done ? (
+        <Icon name="check" size={16} color={colors.onPrimary} />
+      ) : total > 1 ? (
+        <MyazaText variant="bodySmall" color={colors.primary} style={{ fontWeight: '700' }}>
+          {String(position)}
+        </MyazaText>
+      ) : (
+        <Icon name="file-text" size={14} color={colors.primary} />
+      )}
+    </View>
+  );
+}
+
+/** Required or optional, in a word as well as a colour. */
+export function DocumentStatePill({ required }: { required: boolean }): React.ReactElement {
+  const { colors } = useTheme();
+  return (
+    <View
+      style={{
+        paddingHorizontal: spacing.sm,
+        paddingVertical: 2,
+        borderRadius: radius.full,
+        backgroundColor: required ? colors.errorBg : colors.background,
+      }}
+    >
+      <MyazaText
+        variant="bodySmall"
+        color={required ? colors.error : colors.textSecondary}
+        style={{ fontWeight: '600' }}
+      >
+        {required ? 'Required' : 'Optional'}
+      </MyazaText>
+    </View>
+  );
+}
+
+/** What the server will take off this document, named as the author named it. */
+export function DocumentReads({ reads }: { reads: readonly string[] }): React.ReactElement {
+  const { colors } = useTheme();
+  return (
+    <View
+      style={{
+        padding: spacing.sm + 4,
+        borderRadius: radius.sm,
+        backgroundColor: colors.background,
+      }}
+    >
+      <MyazaText
+        variant="bodySmall"
+        color={colors.textSecondary}
+        style={{ fontWeight: '600', letterSpacing: 0.5 }}
+      >
+        WHAT WE READ FROM IT
+      </MyazaText>
+      <View
+        style={{
+          marginTop: spacing.sm,
+          flexDirection: 'row',
+          flexWrap: 'wrap',
+          gap: spacing.xs + 2,
+        }}
+      >
+        {reads.map((read) => (
+          <View
+            key={read}
+            style={{
+              flexDirection: 'row',
+              alignItems: 'center',
+              paddingHorizontal: spacing.sm,
+              paddingVertical: 4,
+              borderRadius: radius.full,
+              borderWidth: 1,
+              borderColor: colors.border,
+              backgroundColor: colors.backgroundSecondary,
+            }}
+          >
+            <Icon name="check" size={12} color={colors.primary} />
+            <View style={{ width: 4 }} />
+            <MyazaText variant="bodySmall">{read}</MyazaText>
+          </View>
+        ))}
+      </View>
+    </View>
+  );
+}

package/src/screens/useBusinessDocumentAttach.ts

@@ -14,19 +14,30 @@ import { loadDocumentPicker } from '../services/documentPicker';
 // the refusal names the file that was chosen (images 5 MB, PDFs 15 MB).
 // ---------------------------------------------------------------------------
 
-export type AttachBusinessDocument = (
-  slot: ResolvedBusinessDocumentType,
+/**
+ * The minimum a slot must carry for this hook: it reads the label for error
+ * copy and hands the slot straight back to the caller's uploader. Generalised
+ * so the supporting-documents step shares this picker rather than owning a
+ * second copy of three file sources and their size/MIME rules.
+ */
+export interface AttachableSlot {
+  key: string;
+  label: string;
+}
+
+export type AttachBusinessDocument<S extends AttachableSlot = ResolvedBusinessDocumentType> = (
+  slot: S,
   uri: string,
   mimeType: string | undefined,
   name: string,
 ) => Promise<void>;
 
-type Pick = (slot: ResolvedBusinessDocumentType) => Promise<void>;
+type Pick<S extends AttachableSlot> = (slot: S) => Promise<void>;
 
-export function useBusinessDocumentAttach(
-  attach: AttachBusinessDocument,
+export function useBusinessDocumentAttach<S extends AttachableSlot = ResolvedBusinessDocumentType>(
+  attach: AttachBusinessDocument<S>,
   setError: (message: string) => void,
-): { takePhoto: Pick; choosePhoto: Pick; chooseFile: Pick } {
+): { takePhoto: Pick<S>; choosePhoto: Pick<S>; chooseFile: Pick<S> } {
   const tooLarge = useCallback(
     (mime: string | undefined, size: number | undefined): boolean => {
       const message = uploadSizeError(mime, size);
@@ -36,7 +47,7 @@ export function useBusinessDocumentAttach(
     [setError],
   );
 
-  const takePhoto = useCallback<Pick>(
+  const takePhoto = useCallback<Pick<S>>(
     async (slot) => {
       const permission = await ImagePicker.requestCameraPermissionsAsync();
       if (!permission.granted) {
@@ -53,7 +64,7 @@ export function useBusinessDocumentAttach(
     [attach, setError, tooLarge],
   );
 
-  const choosePhoto = useCallback<Pick>(
+  const choosePhoto = useCallback<Pick<S>>(
     async (slot) => {
       const result = await ImagePicker.launchImageLibraryAsync({ mediaTypes: ['images'], quality: 1 });
       const asset = result.canceled ? undefined : result.assets[0];
@@ -63,7 +74,7 @@ export function useBusinessDocumentAttach(
     [attach, tooLarge],
   );
 
-  const chooseFile = useCallback<Pick>(
+  const chooseFile = useCallback<Pick<S>>(
     async (slot) => {
       const picker = loadDocumentPicker();
       if (!picker) {

package/src/services/api-types.ts

@@ -24,6 +24,9 @@ export type MediaUploadType =
   // downloaded statement, and company paperwork is almost always a scan.
   | 'proof_of_address'
   | 'business_document'
+  // Artefacts held on file, named by the organisation — not the
+  // identity evidence the verification is decided on. Images + PDF.
+  | 'supporting_document'
   // Address Intelligence door / premises photo (image only).
   | 'address_photo';
 
@@ -43,6 +46,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 +439,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.1.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/derive.ts

@@ -8,6 +8,7 @@
 // ---------------------------------------------------------------------------
 
 import { configScope } from '../lib/scope';
+import { hasSupportingDocumentsStep, verifiedIdsFor } from '../config/supportingDocuments';
 import { requiresDocumentCapture, supportsNfcChip } from '../config/idTypes';
 import {
   buildStepOrder,
@@ -83,6 +84,16 @@ export function stepOrderOptions(state: KycState): StepOrderOptions {
     hasEmailVerification: config.emailVerification?.enabled === true,
     hasPhoneVerification: config.phoneVerification?.enabled === true,
     hasPoa: hasProofOfAddressStep(config.proofOfAddress),
+    // Resolved against the ID actually picked — that is what decides whether
+    // the step has anything to ask for.
+    hasSupportingDocuments: hasSupportingDocumentsStep(
+      config.supportingDocuments,
+      verifiedIdsFor({
+        country: state.selectedCountry ?? config.country,
+        idType: state.selectedIdType,
+        multiIdSlots: state.multiIdSlots,
+      }),
+    ),
     hasAddressCollection: hasAddressCollectionStep(config.addressCollection),
     // An absent search flag means no search SCREEN, never an error: the
     // applicant places the pin by hand, the fallback every address failure