@trustchex/react-native-sdk 1.495.11 → 1.496.0

package/lib/typescript/src/Translation/Resources/en.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAoRE"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAyRE"}

package/lib/typescript/src/Translation/Resources/tr.d.ts

@@ -111,11 +111,13 @@ declare const _default: {
     'eidScannerScreen.placePassportOnNFC': string;
     'eidScannerScreen.placeDocumentOnNFC': string;
     'eidScannerScreen.readingDocument': string;
+    'eidScannerScreen.keepStill': string;
     'eidScannerScreen.checkYourInformation': string;
     'eidScannerScreen.approveAndContinue': string;
     'eidScannerScreen.connecting': string;
     'eidScannerScreen.readingMRZ': string;
     'eidScannerScreen.readingFaceImage': string;
+    'eidScannerScreen.decodingFaceImage': string;
     'eidScannerScreen.completing': string;
     'eidScannerScreen.progress': string;
     'identityDocumentCamera.guideHeader': string;
@@ -140,6 +142,7 @@ declare const _default: {
     'identityDocumentCamera.hologramCheck': string;
     'identityDocumentCamera.keepSteady': string;
     'identityDocumentCamera.avoidBlur': string;
+    'identityDocumentCamera.reduceGlare': string;
     'identityDocumentCamera.wrongSideFront': string;
     'identityDocumentCamera.wrongSideBack': string;
     'identityDocumentCamera.idCardDetected': string;

package/lib/typescript/src/Translation/Resources/tr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAuRE"}
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA4RE"}

package/lib/typescript/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const SDK_VERSION = "1.495.11";
+export declare const SDK_VERSION = "1.496.0";
 //# sourceMappingURL=version.d.ts.map

package/lib/typescript/src/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,aAAa,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,YAAY,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustchex/react-native-sdk",
-  "version": "1.495.11",
+  "version": "1.496.0",
   "description": "Trustchex mobile app react native SDK for android or ios devices",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/Shared/Components/EIDScanner.tsx

@@ -1,5 +1,13 @@
 import React, { useState, useEffect, useCallback, useRef } from 'react';
-import { Alert, View, Text, Image, StyleSheet, Animated } from 'react-native';
+import {
+  Alert,
+  View,
+  Text,
+  Image,
+  StyleSheet,
+  Animated,
+  Vibration,
+} from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import NFCManager from 'react-native-nfc-manager';
 import DeviceInfo from 'react-native-device-info';
@@ -254,19 +262,31 @@ const EIDScanner = ({
         // "reading document" spinner never clears and the user is stuck with no
         // error. Cap the whole read; on timeout we throw a categorized error so
         // the catch below surfaces a retry prompt and finally resets the UI.
+        // Fire a "chip detected" haptic exactly once, the moment progress first
+        // moves off 0 (the chip connected and the read began). Confirms contact
+        // to a user who can't see the screen while holding the phone to the doc.
+        let chipDetectedHapticFired = false;
         const readPromise = eidReader(
           documentNumber,
           dateOfBirth,
           dateOfExpiry,
           (progressValue) => {
+            if (progressValue > 0 && !chipDetectedHapticFired) {
+              chipDetectedHapticFired = true;
+              Vibration.vibrate(40);
+            }
             setProgress(progressValue);
             // Update stage message based on progress
             if (progressValue <= 20) {
               setProgressStage(t('eidScannerScreen.connecting'));
             } else if (progressValue <= 30) {
               setProgressStage(t('eidScannerScreen.readingMRZ'));
-            } else if (progressValue < 100) {
+            } else if (progressValue < 95) {
               setProgressStage(t('eidScannerScreen.readingFaceImage'));
+            } else if (progressValue < 100) {
+              // 95→100 is the (possibly slow) photo decode — give it its own
+              // stage so the bar doesn't look frozen at "Finalizing".
+              setProgressStage(t('eidScannerScreen.decodingFaceImage'));
             } else {
               setProgressStage(t('eidScannerScreen.completing'));
             }
@@ -292,6 +312,11 @@ const EIDScanner = ({
           }
         }
         if (passportData) {
+          // Success haptic: the phone is pressed against the document, so the
+          // user often can't see the screen — a buzz confirms the chip read
+          // finished. (The NFC step previously had no haptics at all, unlike the
+          // camera/liveness screens.)
+          Vibration.vibrate(120);
           const scanDuration = Date.now() - startTime;
           const documentData = normalizeFromMRZInfo(passportData.mrz);
           const builtName = buildDocumentName(
@@ -429,6 +454,10 @@ const EIDScanner = ({
         tag_lost: 'eidScannerScreen.nfcTagLost',
         timeout: 'eidScannerScreen.nfcTimeout',
         not_enabled: 'eidScannerScreen.nfcNotEnabled',
+        // The default/most-common "chip just wouldn't read" bucket. Show the
+        // actionable hold-flat-and-retry guidance rather than the generic
+        // "contact support" message — re-placing the phone usually fixes it.
+        reading_error: 'eidScannerScreen.nfcReadFailed',
       };
 
       if (category !== 'user_cancelled') {
@@ -831,6 +860,17 @@ const EIDScanner = ({
                 </Text>
               )))}
 
+          {/* The connect/auth phase (progress still 0) is the most fragile part
+              of the read — the many PACE/BAC round-trips drop if the phone
+              moves. Tell the user to hold still here, not only once the bar
+              starts moving (the progress UI's "Hold steady" is gated on
+              progress > 0). */}
+          {hasNfc && isEnabled && isScanning && progress === 0 && (
+            <Text style={styles.keepStillHint}>
+              {t('eidScannerScreen.keepStill')}
+            </Text>
+          )}
+
           {hasNfc && isEnabled && !isScanning && !isScanned && (
             <View style={styles.buttonsContainer}>
               <StyledButton mode="contained" onPress={readNFC}>
@@ -938,6 +978,13 @@ const styles = StyleSheet.create({
     color: 'black',
     textAlign: 'center',
   },
+  keepStillHint: {
+    fontSize: 15,
+    color: '#666',
+    textAlign: 'center',
+    marginTop: 12,
+    paddingHorizontal: 24,
+  },
   // ── ID Card result layout ──────────────────────────────────────────────
   idCardWrapper: {
     gap: 10,

package/src/Shared/Components/IdentityDocumentCamera.constants.ts

@@ -17,6 +17,15 @@ export const REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS = 3;
 export const SIGNATURE_REGEX = /s[gi]g?n[au]?t[u]?r|imz[a]s?/i;
 export const SIGNATURE_TEXT_REGEX = /signature|imza|İmza/i;
 export const MRZ_BLOCK_PATTERN = /[A-Z0-9<]{8,}.*</i;
+// A DENSE MRZ run — a contiguous block of MRZ characters that contains a chevron
+// FILLER pair (`<<`). Real machine-readable zones are padded with `<<…`; a card
+// FACE (ID front) has no MRZ, and the occasional stray single `<` OCR'd from a
+// guilloche/chevron glyph will NOT contain a `<<` filler run. Used to decide
+// "is a real MRZ visible on this front?" without the false positives of
+// MRZ_BLOCK_PATTERN (whose `.*<` lets a lone detached `<` anywhere in the frame
+// match) — that looseness could otherwise wedge a legitimate ID front that
+// happens to OCR a stray `<`.
+export const MRZ_DENSE_PATTERN = /[A-Z0-9<]{6,}<<[A-Z0-9<]*/i;
 // Matches the line-1 start of ANY ICAO TD3 passport MRZ, so the camera routes
 // every passport variant into the passport flow (not the ID-card back-side
 // flow). Per ICAO 9303 Part 4: `P` + a type char (filler `<` or a subtype

package/src/Shared/Components/IdentityDocumentCamera.flows.ts

@@ -30,7 +30,10 @@
 
 import type { Face, DocumentType } from './IdentityDocumentCamera.types';
 import type { MRZFields } from '../Types/mrzFields';
-import { PASSPORT_MRZ_PATTERN } from './IdentityDocumentCamera.constants';
+import {
+  PASSPORT_MRZ_PATTERN,
+  MRZ_DENSE_PATTERN,
+} from './IdentityDocumentCamera.constants';
 import {
   isIDCardDocumentCode,
   isPassportDocumentCode,
@@ -58,6 +61,7 @@ export interface IDFrontFlowResult {
   reason?: string;
   nextAction?:
     | 'WAIT_FOR_ELEMENTS'
+    | 'WAIT_FOR_MRZ'
     | 'REJECT_AS_PASSPORT'
     | 'PROCEED_TO_HOLOGRAM';
 }
@@ -187,8 +191,17 @@ export function handleIDFrontFlow(
     };
   }
 
-  if (mrzText && PASSPORT_MRZ_PATTERN.test(mrzText)) {
-    // Passport MRZ pattern visible even if not fully parsed
+  // Passport MRZ pattern visible even if not fully parsed. Check BOTH the
+  // parsed `mrzText` (null until the MRZ validates) AND the raw OCR `text` — a
+  // passport's MRZ is dense and frequently OCRs a few frames after its face +
+  // signature, so on the accepting frame `mrzText` is often still null while the
+  // raw `P<XXX...` run is already visible. Testing only `mrzText` (the old bug)
+  // let such a passport pass as an ID front and get routed to a back side that
+  // does not exist.
+  if (
+    (mrzText && PASSPORT_MRZ_PATTERN.test(mrzText)) ||
+    PASSPORT_MRZ_PATTERN.test(text)
+  ) {
     return {
       shouldProceed: false,
       reason: 'Passport MRZ pattern visible - not an ID card',
@@ -208,6 +221,39 @@ export function handleIDFrontFlow(
     };
   }
 
+  // ============================================================================
+  // STEP 2b: An ID-card FRONT has NO MRZ (the MRZ is on the back). So if a real
+  // MRZ is currently visible on this "front", it is almost certainly a passport
+  // data page whose 'P' code we just haven't parsed yet — do NOT accept it as an
+  // ID front; wait for the MRZ to resolve (→ a 'P' code routes it to the
+  // passport flow). This is the guard that stops a passport (face + signature +
+  // not-yet-parsed MRZ) being accepted as ID_FRONT and then getting stuck at
+  // SCAN_ID_BACK, which rejects the passport's photo page because it has a face.
+  //
+  // We use MRZ_DENSE_PATTERN (requires a `<<` filler run), NOT the loose
+  // MRZ_BLOCK_PATTERN — a card face has no MRZ, but a stray single `<` OCR'd
+  // from a guilloche could match the loose pattern and wedge a real ID front.
+  // We ALSO honor the signature retry threshold: a real ID front genuinely has
+  // no MRZ, so if a "dense MRZ" keeps matching frame after frame past the
+  // threshold it is OCR noise, not a passport — fall through and let STEP 3's
+  // face-only acceptance proceed rather than waiting forever.
+  const mrzVisibleOnFront = !!mrzText || MRZ_DENSE_PATTERN.test(text);
+  const stillWaitingForMrz = retryCount <= SIGNATURE_RETRY_THRESHOLD;
+  if (
+    mrzVisibleOnFront &&
+    stillWaitingForMrz &&
+    !isIDCardDocumentCode(mrzFields?.documentCode)
+  ) {
+    // An ID-card MRZ code (I/A/C) is allowed to proceed (handled in STEP 4); any
+    // other visible MRZ → keep waiting for it to parse and reveal a 'P' code.
+    return {
+      shouldProceed: false,
+      reason:
+        'MRZ block visible on front - waiting to confirm it is not a passport',
+      nextAction: 'WAIT_FOR_MRZ',
+    };
+  }
+
   // ============================================================================
   // STEP 3: Check for signature (optional front side confirmation)
   // ============================================================================

package/src/Shared/Components/IdentityDocumentCamera.tsx

@@ -69,7 +69,6 @@ import {
   REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS,
   SIGNATURE_TEXT_REGEX,
   MRZ_BLOCK_PATTERN,
-  PASSPORT_MRZ_PATTERN,
   MIN_CARD_FACE_SIZE_PERCENT,
 } from './IdentityDocumentCamera.constants';
 import type {
@@ -138,6 +137,11 @@ const IdentityDocumentCamera = ({
   >(undefined);
   const [isBrightnessLow, setIsBrightnessLow] = useState(false);
   const [isFrameBlurry, setIsFrameBlurry] = useState(false);
+  // Glare was being silently rejected (frames dropped with no user feedback), so
+  // a user fighting reflections just saw the scan hang. Surface it so we can show
+  // an actionable "move away from glare" hint. Set at each glare rejection;
+  // cleared when a frame passes the brightness check (a fresh, glare-free frame).
+  const [isGlareDetected, setIsGlareDetected] = useState(false);
   const [hasGuideShown, setHasGuideShown] = useState(false);
   const [status, setStatus] = useState<
     'SEARCHING' | 'SCANNING' | 'SCANNED' | 'INCORRECT'
@@ -235,6 +239,7 @@ const IdentityDocumentCamera = ({
     frameH: 0,
     hadLowBrightness: false,
     hadBlurryFrames: false,
+    hadGlare: false,
   });
   const [faceDetectionEnabled, setFaceDetectionEnabled] = useState(true);
   const faceImages = useRef<string[]>([]);
@@ -349,6 +354,7 @@ const IdentityDocumentCamera = ({
         frameH: 0,
         hadLowBrightness: false,
         hadBlurryFrames: false,
+        hadGlare: false,
       };
       cachedBarcode.current = null;
       isCompletionCallbackInvoked.current = false;
@@ -397,6 +403,7 @@ const IdentityDocumentCamera = ({
       detectedDocumentType,
       isBrightnessLow,
       isFrameBlurry,
+      isGlareDetected,
       allElementsDetected,
       elementsOutsideScanArea,
       t
@@ -419,6 +426,7 @@ const IdentityDocumentCamera = ({
     hasGuideShown,
     isBrightnessLow,
     isFrameBlurry,
+    isGlareDetected,
     nextStep,
     status,
     detectedDocumentType,
@@ -567,7 +575,9 @@ const IdentityDocumentCamera = ({
     }
   };
 
-  // Check if face image has glare (brightness exceeds threshold)
+  // Check if face image has glare (brightness exceeds threshold). Also surfaces
+  // the result to `isGlareDetected` so the user gets an actionable hint instead
+  // of a silently-stalled scan.
   const checkFaceGlare = async (faceImage: string): Promise<boolean> => {
     try {
       // Check entire face region for glare
@@ -579,6 +589,8 @@ const IdentityDocumentCamera = ({
         100, // Full face height
         MAX_BRIGHTNESS_THRESHOLD
       );
+      setIsGlareDetected(hasGlare);
+      if (hasGlare) diagStats.current.hadGlare = true;
       return hasGlare;
     } catch (error) {
       return false; // Assume no glare on error
@@ -617,6 +629,8 @@ const IdentityDocumentCamera = ({
         Math.round(height * 0.8),
         MAX_BRIGHTNESS_THRESHOLD
       );
+      setIsGlareDetected(hasGlare);
+      if (hasGlare) diagStats.current.hadGlare = true;
       return hasGlare;
     } catch (error) {
       return false;
@@ -1169,7 +1183,9 @@ const IdentityDocumentCamera = ({
       // Surface the reliable-detection signal to the render so the UI can show a
       // green "GO" the moment (and only once) the consensus is stable + valid.
       // Never flips green on an early/transient valid read.
-      setMrzReliable((prev) => (prev === mrzStableAndValid ? prev : mrzStableAndValid));
+      setMrzReliable((prev) =>
+        prev === mrzStableAndValid ? prev : mrzStableAndValid
+      );
 
       // Test-mode panel: show the MRZ ONLY once it is stable + valid (the same
       // consensus matched across `stabilityTarget` consecutive frames). Showing
@@ -1179,9 +1195,7 @@ const IdentityDocumentCamera = ({
       // check-digit-valid consensus and never an unstable intermediate.
       if (testMode && mrzStableAndValid && mrzText) {
         setTestModeData((prev) =>
-          prev?.mrzText === mrzText
-            ? prev
-            : { mrzText, timestamp: Date.now() }
+          prev?.mrzText === mrzText ? prev : { mrzText, timestamp: Date.now() }
         );
       }
 
@@ -1194,30 +1208,42 @@ const IdentityDocumentCamera = ({
           const hasFaces = primaryFaces.length > 0;
           const hasSignature = /signature|imza|İmza/i.test(text);
           const hasPassportMRZ = parsedMRZData?.fields?.documentCode === 'P';
-          const hasPassportMRZPattern =
-            mrzText && PASSPORT_MRZ_PATTERN.test(mrzText);
-
-          if (
-            hasFaces ||
-            hasSignature ||
-            hasPassportMRZ ||
-            hasPassportMRZPattern
-          ) {
-            setStatus('INCORRECT');
-            return;
-          }
 
-          // Safety: passport somehow reached ID_BACK step
-          if (detectedDocumentType === 'PASSPORT') {
+          // RECOVERY (must run BEFORE the wrong-side guard below): a passport was
+          // misrouted to SCAN_ID_BACK. A passport has only its data page, which
+          // carries a face + MRZ — exactly what the wrong-side guard treats as
+          // "wrong side", so without this it would loop on INCORRECT forever
+          // (the reported "stuck asking for ID back" case). If we have positive
+          // passport evidence here, the front was already captured, so complete
+          // as a passport instead of waiting for a back that does not exist.
+          //
+          // We deliberately gate ONLY on authoritative signals: a locked PASSPORT
+          // classification, or a PARSED MRZ document code of 'P'. We do NOT test
+          // the raw OCR `text` against PASSPORT_MRZ_PATTERN here — an ID card's
+          // BACK legitimately carries an MRZ whose name line ("PAPPAS<<MARIA…",
+          // "…<<PHILIPP…") can false-match the unanchored pattern and would then
+          // wrongly complete a real ID card as a passport, skipping the back-side
+          // MRZ + barcode validation entirely.
+          if (detectedDocumentType === 'PASSPORT' || hasPassportMRZ) {
             transitionStepWithCallback('COMPLETED', 'SCAN_ID_BACK', {
               image,
               documentType: 'PASSPORT',
-              mrzText: mrzText ?? undefined,
-              mrzFields: parsedMRZData?.fields,
+              mrzText: mrzText ?? lastValidMRZText.current ?? undefined,
+              mrzFields:
+                parsedMRZData?.fields ??
+                lastValidMRZFields.current ??
+                undefined,
             });
             return;
           }
 
+          // Wrong-side detection: a face or signature means we're looking at a
+          // front, not an ID-card back (which has neither).
+          if (hasFaces || hasSignature) {
+            setStatus('INCORRECT');
+            return;
+          }
+
           setElementsOutsideScanArea([]);
 
           const flowResult = handleIDBackFlow(
@@ -2030,6 +2056,15 @@ const IdentityDocumentCamera = ({
       setIsBrightnessLow(!isRegionBright);
       if (!isRegionBright) diagStats.current.hadLowBrightness = true;
 
+      // Reset glare to false at the start of every frame. The glare helpers
+      // (checkDocumentGlare/checkFaceGlare) only run at accept-time and set it
+      // true when they find glare; without this per-frame clear the flag would
+      // latch — a "Glare detected" warning would stick over a now-clean view
+      // (and, once a face is locked, the face-glare site never runs again so it
+      // could never clear at all). The accept-time checks run later in this same
+      // frame's handlers and re-assert true if glare is still present.
+      setIsGlareDetected(false);
+
       // Check blur only in center region (area of interest) to avoid false positives
       // from iOS depth-of-field background blur
       let isNotBlurry = true;
@@ -2060,7 +2095,8 @@ const IdentityDocumentCamera = ({
         frameH: ds.frameH,
         avgBrightness:
           ds.frames > 0 ? Math.round(ds.brightnessSum / ds.frames) : 0,
-        minBrightness: ds.minBrightness === 255 && ds.frames === 0 ? 0 : ds.minBrightness,
+        minBrightness:
+          ds.minBrightness === 255 && ds.frames === 0 ? 0 : ds.minBrightness,
         maxBrightness: ds.maxBrightness,
         hadLowBrightness: ds.hadLowBrightness,
         hadBlurryFrames: ds.hadBlurryFrames,
@@ -2654,13 +2690,15 @@ const IdentityDocumentCamera = ({
                 opacity: errorFlashAnim,
               },
               // 3. Warning (yellow) - quality issues
-              (isBrightnessLow || isFrameBlurry) && styles.topZoneTextWarning,
+              (isBrightnessLow || isFrameBlurry || isGlareDetected) &&
+                styles.topZoneTextWarning,
               // 4. Scanning (green) - all elements detected AND inside scan area
               status === 'SCANNING' &&
                 allElementsDetected &&
                 elementsOutsideScanArea.length === 0 &&
                 !isBrightnessLow &&
                 !isFrameBlurry &&
+                !isGlareDetected &&
                 styles.topZoneTextScanning,
               // 5. Default (white) - aligning (not all detected OR elements outside scan area)
             ]}
@@ -2671,6 +2709,7 @@ const IdentityDocumentCamera = ({
               detectedDocumentType,
               isBrightnessLow,
               isFrameBlurry,
+              isGlareDetected,
               allElementsDetected,
               elementsOutsideScanArea,
               t
@@ -2696,8 +2735,7 @@ const IdentityDocumentCamera = ({
                       : isBrightnessLow || isFrameBlurry
                         ? '#FFC107'
                         : 'white',
-              borderWidth:
-                mrzReliable || status === 'SCANNING' ? 3 : 2,
+              borderWidth: mrzReliable || status === 'SCANNING' ? 3 : 2,
             },
           ]}
         >

package/src/Shared/Components/IdentityDocumentCamera.utils.ts

@@ -9,6 +9,7 @@ import type { MRZFields } from '../Types/mrzFields';
 import {
   SIGNATURE_REGEX,
   PASSPORT_MRZ_PATTERN,
+  MRZ_DENSE_PATTERN,
 } from './IdentityDocumentCamera.constants';
 import { debugLog, isDebugEnabled } from '../Libs/debug.utils';
 
@@ -118,6 +119,7 @@ export function getStatusMessage(
   detectedDocumentType: DocumentType,
   isBrightnessLow: boolean,
   isFrameBlurry: boolean,
+  isGlareDetected: boolean,
   allElementsDetected: boolean,
   elementsOutsideScanArea: string[],
   t: (key: string, params?: Record<string, unknown>) => string
@@ -149,6 +151,14 @@ export function getStatusMessage(
     return t('identityDocumentCamera.lowBrightness');
   }
 
+  // Glare is a primary failure mode (reflections off the laminate/photo). It was
+  // previously detected but never communicated, so the scan just appeared to
+  // hang. Tell the user how to fix it. Ranked above blur because a glare hotspot
+  // both blocks acceptance and often reads as a "sharp" (non-blurry) frame.
+  if (isGlareDetected) {
+    return t('identityDocumentCamera.reduceGlare');
+  }
+
   if (isFrameBlurry) {
     return t('identityDocumentCamera.avoidBlur');
   }
@@ -309,10 +319,18 @@ export function detectDocumentType(
         return 'ID_FRONT';
       }
 
-      // If signature present and NO passport MRZ pattern, likely ID_FRONT
-      // But we can't be 100% sure yet - passport MRZ might appear in next frames
+      // If signature present and NO passport MRZ pattern, likely ID_FRONT —
+      // BUT an ID-card front has no MRZ, so if a real (dense) MRZ is visible here
+      // (and it is not a confirmed ID code — that returned above) this is almost
+      // certainly a passport data page whose 'P' code just hasn't OCR'd yet.
+      // Stay UNKNOWN and let later frames resolve it, rather than locking
+      // ID_FRONT and routing a passport to a back side it does not have. We use
+      // MRZ_DENSE_PATTERN (needs a `<<` filler run) so a stray single `<` OCR'd
+      // from a card-face guilloche cannot wedge a genuine ID front at UNKNOWN.
+      const hasUnresolvedMrzBlock =
+        !!mrzText || MRZ_DENSE_PATTERN.test(ocrText);
       const hasSignature = hasSignatureMatch;
-      if (hasSignature && !hasPassportMRZPattern) {
+      if (hasSignature && !hasPassportMRZPattern && !hasUnresolvedMrzBlock) {
         return 'ID_FRONT';
       }
     }

package/src/Shared/EIDReader/eidReader.ts

@@ -732,8 +732,12 @@ const eidReader = async (
       // step (it was previously outside, so an early DG2 failure went unlabelled).
       const dg2InputStream = passportService.getInputStream(EIDService.EF_DG2);
       await dg2InputStream.init();
+      // Map the DG2 byte stream to 30→95 (not →100): the JPEG2000 decode that
+      // follows can take a noticeable beat (esp. large passport portraits), and
+      // jumping to 100 before it made the UI sit at "100% Finalizing" looking
+      // frozen during the decode. We reserve 95→100 for the decode step below.
       InputStream.onRead((totalBytesRead, fileLength) => {
-        progress = 30 + (totalBytesRead / fileLength) * 70;
+        progress = 30 + (totalBytesRead / fileLength) * 65;
         if (progressCallback) {
           progressCallback(progress);
         }
@@ -756,6 +760,12 @@ const eidReader = async (
       const buffer = Buffer.alloc(imageLength);
       await imageInputStream.readBytesWithOffset(buffer, 0, imageLength);
       const rawMimeType = faceImageInfo.getMimeType();
+      // Signal the (potentially slow) photo decode so the UI shows a distinct
+      // "decoding photo" stage at 95% rather than appearing frozen at 100%.
+      progress = 95;
+      if (progressCallback) {
+        progressCallback(progress);
+      }
       const converted = await convertJP2IfNeeded(buffer, rawMimeType);
       imageAsBase64 = converted.base64;
       mimeType = converted.mimeType;

package/src/Translation/Resources/en.ts

@@ -143,11 +143,14 @@ export default {
   'eidScannerScreen.placeDocumentOnNFC':
     'Place your document near the NFC reader',
   'eidScannerScreen.readingDocument': 'Hold steady - Reading document',
+  'eidScannerScreen.keepStill':
+    'Keep the document and phone still until the read completes.',
   'eidScannerScreen.checkYourInformation': 'Review your information carefully',
   'eidScannerScreen.approveAndContinue': 'Approve and Continue',
   'eidScannerScreen.connecting': 'Establishing secure connection...',
   'eidScannerScreen.readingMRZ': 'Reading document information...',
   'eidScannerScreen.readingFaceImage': 'Reading photo data...',
+  'eidScannerScreen.decodingFaceImage': 'Decoding photo...',
   'eidScannerScreen.completing': 'Finalizing verification...',
   'eidScannerScreen.progress': 'Progress',
   'identityDocumentCamera.guideHeader': 'Document Scan',
@@ -178,6 +181,8 @@ export default {
   'identityDocumentCamera.hologramCheck': 'Hologram',
   'identityDocumentCamera.keepSteady': 'Keep device steady',
   'identityDocumentCamera.avoidBlur': 'Keep device steady',
+  'identityDocumentCamera.reduceGlare':
+    'Glare detected. Tilt the document or move away from direct light.',
   'identityDocumentCamera.wrongSideFront':
     'Show the front side of your document',
   'identityDocumentCamera.wrongSideBack': 'Show the back side of your document',

package/src/Translation/Resources/tr.ts

@@ -143,12 +143,15 @@ export default {
     'Pasaportunuzu NFC okuyucuya yaklaştırın',
   'eidScannerScreen.placeDocumentOnNFC': 'Belgenizi NFC okuyucuya yaklaştırın',
   'eidScannerScreen.readingDocument': 'Sabit tutun - Belge okunuyor',
+  'eidScannerScreen.keepStill':
+    'Okuma tamamlanana kadar belgeyi ve telefonu sabit tutun.',
   'eidScannerScreen.checkYourInformation':
     'Bilgilerinizi dikkatle kontrol edin',
   'eidScannerScreen.approveAndContinue': 'Onayla ve Devam Et',
   'eidScannerScreen.connecting': 'Güvenli bağlantı kuruluyor...',
   'eidScannerScreen.readingMRZ': 'Belge bilgileri okunuyor...',
   'eidScannerScreen.readingFaceImage': 'Fotoğraf verisi okunuyor...',
+  'eidScannerScreen.decodingFaceImage': 'Fotoğraf çözümleniyor...',
   'eidScannerScreen.completing': 'Doğrulama tamamlanıyor...',
   'eidScannerScreen.progress': 'İlerleme',
   'identityDocumentCamera.guideHeader': 'Belge Taraması',
@@ -179,6 +182,8 @@ export default {
   'identityDocumentCamera.hologramCheck': 'Hologram',
   'identityDocumentCamera.keepSteady': 'Cihazı sabit tutun',
   'identityDocumentCamera.avoidBlur': 'Cihazı sabit tutun',
+  'identityDocumentCamera.reduceGlare':
+    'Parlama algılandı. Belgeyi hafifçe eğin veya doğrudan ışıktan uzaklaşın.',
   'identityDocumentCamera.wrongSideFront': 'Belgenizin ön yüzünü gösterin',
   'identityDocumentCamera.wrongSideBack': 'Belgenizin arka yüzünü gösterin',
   'identityDocumentCamera.idCardDetected': 'Kimlik kartı algılandı',

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.495.11';
+export const SDK_VERSION = '1.496.0';