@trustchex/react-native-sdk 1.475.1 → 1.478.7

package/android/src/main/java/com/trustchex/reactnativesdk/camera/TrustchexCameraView.kt

@@ -116,6 +116,7 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
     // Prevent concurrent ML Kit processing (drop frames while busy)
     private val isProcessing = AtomicBoolean(false)
 
+    @Volatile
     private var lastFrameTime = 0L
     private val minFrameInterval get() = 1000L / targetFps
 
@@ -164,27 +165,6 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
             return selectWidestFrontCamera()
         }
 
-        // For back camera, try to select Ultra Wide camera for document scanning
-        val cameraProvider = cameraProvider ?: return CameraSelector.DEFAULT_BACK_CAMERA
-
-        try {
-            // Check for Ultra Wide camera
-            val ultraWideSelector = CameraSelector.Builder()
-                .requireLensFacing(CameraSelector.LENS_FACING_BACK)
-                .build()
-
-            val cameras = cameraProvider.availableCameraInfos.filter {
-                ultraWideSelector.filter(listOf(it)).isNotEmpty()
-            }
-
-            // Heuristic: If we have 3+ back cameras, index 2 is often Ultra Wide
-            if (cameras.size >= 3) {
-                // Heuristic: If we have 3+ back cameras, index 2 is often Ultra Wide
-            }
-        } catch (e: Exception) {
-            // Failed to enumerate cameras
-        }
-
         return CameraSelector.DEFAULT_BACK_CAMERA
     }
 
@@ -758,6 +738,24 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
                         }
                     }
                 }
+            } else if (uvPixelStride == 1) {
+                val vRowStride = vPlane.rowStride
+
+                for (row in 0 until uvHeight) {
+                    val uRowOffset = row * uvRowStride
+                    val vRowOffset = row * vRowStride
+                    for (col in 0 until uvWidth) {
+                        val uIndex = uRowOffset + col
+                        val vIndex = vRowOffset + col
+                        if (vIndex < vBuffer.capacity() && uIndex < uBuffer.capacity()) {
+                            nv21[nv21Offset++] = vBuffer.get(vIndex)
+                            nv21[nv21Offset++] = uBuffer.get(uIndex)
+                        } else {
+                            nv21[nv21Offset++] = 128.toByte()
+                            nv21[nv21Offset++] = 128.toByte()
+                        }
+                    }
+                }
             }
 
             // Convert YUV to JPEG with optimized quality (75% for faster encoding)

package/android/src/main/java/com/trustchex/reactnativesdk/mlkit/MLKitModule.kt

@@ -233,6 +233,7 @@ class MLKitModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaM
     private fun base64ToInputImage(base64: String): InputImage {
         val imageBytes = Base64.decode(base64, Base64.NO_WRAP)
         val bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
+            ?: throw IllegalArgumentException("Failed to decode image data")
         return InputImage.fromBitmap(bitmap, 0)
     }
 

package/lib/module/Screens/Dynamic/LivenessDetectionScreen.js

@@ -13,6 +13,7 @@ import { useTranslation } from 'react-i18next';
 import StyledButton from "../../Shared/Components/StyledButton.js";
 import LottieView from 'lottie-react-native';
 import { speak, resetLastMessage } from "../../Shared/Libs/tts.utils.js";
+import { secureShuffle } from "../../Shared/Libs/shuffle.utils.js";
 import { useStatusBarWhiteBackground } from "../../Shared/Libs/status-bar.utils.js";
 import { trackFunnelStep, useScreenTracking, trackVerificationStart, trackVerificationComplete } from "../../Shared/Libs/analytics.utils.js";
 import { useKeepAwake } from "../../Shared/Libs/native-keep-awake.utils.js";
@@ -137,9 +138,9 @@ const LivenessDetectionScreen = () => {
     }
   }, [hasGuideShown]);
   useEffect(() => {
-    const il = Object.keys(instructions).filter(instruction => !['START', 'FINISH'].includes(instruction) && (
+    const il = secureShuffle(Object.keys(instructions).filter(instruction => !['START', 'FINISH'].includes(instruction) && (
     // Look straight and blink is always included
-    instruction === 'LOOK_STRAIGHT_AND_BLINK' || !appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes || appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes.length === 0 || appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes.includes(instruction))).sort(() => Math.random() - 0.5);
+    instruction === 'LOOK_STRAIGHT_AND_BLINK' || !appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes || appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes.length === 0 || appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes.includes(instruction))));
     il.unshift('START');
     il.push('FINISH');
     setInitialState({

package/lib/module/Screens/Static/QrCodeScanningScreen.js

@@ -5,7 +5,8 @@ import { SafeAreaView, StyleSheet } from 'react-native';
 import AppContext from "../../Shared/Contexts/AppContext.js";
 import QrCodeScannerCamera from "../../Shared/Components/QrCodeScannerCamera.js";
 import { useNavigation } from '@react-navigation/native';
-import { handleDeepLink } from "../../Shared/Libs/deeplink.utils.js";
+import { handleDeepLink, getUrlHost } from "../../Shared/Libs/deeplink.utils.js";
+import { logWarn } from "../../Shared/Libs/debug.utils.js";
 import { useKeepAwake } from "../../Shared/Libs/native-keep-awake.utils.js";
 import { useStatusBarWhiteBackground } from "../../Shared/Libs/status-bar.utils.js";
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -17,9 +18,18 @@ const QrCodeScanningScreen = () => {
   // Configure status bar for white background
   useStatusBarWhiteBackground();
   const onQrCodeScanned = data => {
-    const [bUrl, sId] = handleDeepLink({
+    let [bUrl, sId] = handleDeepLink({
       url: data
     });
+
+    // A scanned QR may not repoint an already-configured backend to another
+    // host — uploads carry identity documents and biometrics. Keep the
+    // configured baseUrl and only take the session id from the QR.
+    const configuredBaseUrl = appContext.baseUrl;
+    if (bUrl && configuredBaseUrl && getUrlHost(bUrl) !== getUrlHost(configuredBaseUrl)) {
+      logWarn('QrCodeScanningScreen', 'Ignoring QR-provided baseUrl with mismatched host');
+      bUrl = configuredBaseUrl;
+    }
     if (bUrl && sId) {
       if (appContext.setBaseUrl) {
         appContext.setBaseUrl(bUrl);

package/lib/module/Screens/Static/ResultScreen.js

@@ -4,7 +4,7 @@ import React, { useCallback, useContext, useEffect, useMemo, useState } from 're
 import { Alert, Image, Platform, SafeAreaView, ScrollView, StyleSheet, Text, View } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import AppContext from "../../Shared/Contexts/AppContext.js";
-import httpClient from "../../Shared/Libs/http-client.js";
+import httpClient, { getSessionToken } from "../../Shared/Libs/http-client.js";
 import RNFS from 'react-native-fs';
 import NativeProgressBar from "../../Shared/Components/NativeProgressBar.js";
 import LottieView from 'lottie-react-native';
@@ -185,130 +185,122 @@ const ResultScreen = () => {
       console.log('[ResultScreen] Media already uploaded during video call, skipping');
       return;
     }
+    const uploadSessionToken = getSessionToken();
     const uploadFileOptions = {
       toUrl: `${apiUrl}/identifications/${identificationId}/media`,
       method: 'POST',
       headers: {
-        Accept: 'application/json'
+        Accept: 'application/json',
+        ...(uploadSessionToken ? {
+          'X-Session-Token': uploadSessionToken
+        } : {})
       },
       files: [],
       progress: res => {
         setProgress(60 + res.totalBytesSent / res.totalBytesExpectedToSend * 30);
       }
     };
-    const frontImage = scannedIdentityDocument?.frontImage;
-    if (frontImage && frontImage !== '') {
-      await RNFS.writeFile(decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/DOCUMENT_FRONT_IMAGE.jpg`), frontImage, 'base64');
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: 'DOCUMENT_FRONT_IMAGE.jpg',
-        filepath: decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/DOCUMENT_FRONT_IMAGE.jpg`),
-        filetype: 'image/jpeg'
-      });
-    }
-    const backImage = scannedIdentityDocument?.backImage;
-    if (backImage && backImage !== '') {
-      await RNFS.writeFile(decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/DOCUMENT_BACK_IMAGE.jpg`), backImage, 'base64');
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: 'DOCUMENT_BACK_IMAGE.jpg',
-        filepath: decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/DOCUMENT_BACK_IMAGE.jpg`),
-        filetype: 'image/jpeg'
-      });
-    }
-    const faceImage = scannedIdentityDocument?.faceImage;
-    if (faceImage && faceImage !== '') {
-      scannedIdentityDocument.faceImageMimeType ||= 'image/jpeg';
-      const extension = scannedIdentityDocument.faceImageMimeType === 'image/jp2' ? 'jp2' : scannedIdentityDocument.faceImageMimeType === 'image/png' ? 'png' : 'jpg';
-      await RNFS.writeFile(decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/FACE_IMAGE.${extension}`), faceImage, 'base64');
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: `FACE_IMAGE.${extension}`,
-        filepath: decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/FACE_IMAGE.${extension}`),
-        filetype: scannedIdentityDocument.faceImageMimeType
-      });
-    }
-    const secondaryFaceImage = scannedIdentityDocument?.secondaryFaceImage;
-    if (secondaryFaceImage && secondaryFaceImage !== '') {
-      await RNFS.writeFile(decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/DOCUMENT_SECONDARY_FACE_IMAGE.jpg`), secondaryFaceImage, 'base64');
-      uploadFileOptions.files.push({
-        name: 'files',
-        filename: 'DOCUMENT_SECONDARY_FACE_IMAGE.jpg',
-        filepath: decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/DOCUMENT_SECONDARY_FACE_IMAGE.jpg`),
-        filetype: 'image/jpeg'
-      });
-    }
-    const hologramImage = scannedIdentityDocument?.hologramImage;
-    if (hologramImage && hologramImage !== '') {
-      await RNFS.writeFile(decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/DOCUMENT_HOLOGRAM_IMAGE.jpg`), hologramImage, 'base64');
+
+    // Plaintext identity images/video staged on disk for the multipart
+    // upload; everything tracked here is deleted in the finally below.
+    const tempPaths = [];
+    const writeTempImage = async (fileName, base64Data, filetype = 'image/jpeg') => {
+      const filePath = decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/${fileName}`);
+      await RNFS.writeFile(filePath, base64Data, 'base64');
+      tempPaths.push(filePath);
       uploadFileOptions.files.push({
         name: 'files',
-        filename: 'DOCUMENT_HOLOGRAM_IMAGE.jpg',
-        filepath: decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/DOCUMENT_HOLOGRAM_IMAGE.jpg`),
-        filetype: 'image/jpeg'
+        filename: fileName,
+        filepath: filePath,
+        filetype
       });
-    }
-    if (livenessDetection) {
-      for (const instruction of livenessDetection.instructions) {
-        if (instruction.photo !== '') {
-          await RNFS.writeFile(decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`), instruction.photo, 'base64');
+      return filePath;
+    };
+    try {
+      const frontImage = scannedIdentityDocument?.frontImage;
+      if (frontImage && frontImage !== '') {
+        await writeTempImage('DOCUMENT_FRONT_IMAGE.jpg', frontImage);
+      }
+      const backImage = scannedIdentityDocument?.backImage;
+      if (backImage && backImage !== '') {
+        await writeTempImage('DOCUMENT_BACK_IMAGE.jpg', backImage);
+      }
+      const faceImage = scannedIdentityDocument?.faceImage;
+      if (faceImage && faceImage !== '') {
+        scannedIdentityDocument.faceImageMimeType ||= 'image/jpeg';
+        const extension = scannedIdentityDocument.faceImageMimeType === 'image/jp2' ? 'jp2' : scannedIdentityDocument.faceImageMimeType === 'image/png' ? 'png' : 'jpg';
+        await writeTempImage(`FACE_IMAGE.${extension}`, faceImage, scannedIdentityDocument.faceImageMimeType);
+      }
+      const secondaryFaceImage = scannedIdentityDocument?.secondaryFaceImage;
+      if (secondaryFaceImage && secondaryFaceImage !== '') {
+        await writeTempImage('DOCUMENT_SECONDARY_FACE_IMAGE.jpg', secondaryFaceImage);
+      }
+      const hologramImage = scannedIdentityDocument?.hologramImage;
+      if (hologramImage && hologramImage !== '') {
+        await writeTempImage('DOCUMENT_HOLOGRAM_IMAGE.jpg', hologramImage);
+      }
+      if (livenessDetection) {
+        for (const instruction of livenessDetection.instructions) {
+          if (instruction.photo !== '') {
+            const filePath = await writeTempImage(`LIVENESS_${instruction.instruction}_IMAGE.jpg`, instruction.photo);
+            if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
+              uploadFileOptions.files.push({
+                name: 'files',
+                filename: 'SELFIE_IMAGE.jpg',
+                filepath: filePath,
+                filetype: 'image/jpeg'
+              });
+            }
+          }
+        }
+        const livenessVideoPath = livenessDetection.videoPath;
+        if (livenessVideoPath) {
+          let videoFilePath;
+          if (Platform.OS === 'ios') {
+            const tmpTimestamp = new Date().getTime();
+            const tempDir = `${RNFS.TemporaryDirectoryPath}/${tmpTimestamp}`;
+            await RNFS.mkdir(tempDir);
+            tempPaths.push(tempDir);
+            videoFilePath = `${tempDir}/LIVENESS_VIDEO.mp4`;
+          } else {
+            videoFilePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`;
+            tempPaths.push(videoFilePath);
+          }
+          await RNFS.copyFile(livenessVideoPath, videoFilePath);
+
+          // Compress video with maximum compression settings
+          const compressedVideoPath = await VideoCompressor.compress(videoFilePath, {
+            compressionMethod: 'manual',
+            bitrate: 500000,
+            // 500 kbps
+            maxSize: 1280,
+            // HD 720p
+            minimumFileSizeForCompress: 0 // Always compress
+          }, compressionProgress => {
+            // Map compression progress (0-1) to main progress (40-60%)
+            setProgress(40 + compressionProgress * 20);
+          });
+
+          // Convert file:// URI to regular path for RNFS upload
+          const normalizedPath = compressedVideoPath.replace('file://', '');
+          tempPaths.push(normalizedPath);
           uploadFileOptions.files.push({
             name: 'files',
-            filename: `LIVENESS_${instruction.instruction}_IMAGE.jpg`,
-            filepath: decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`),
-            filetype: 'image/jpeg'
+            filename: 'LIVENESS_VIDEO.mp4',
+            filepath: normalizedPath,
+            filetype: 'video/mp4'
           });
-          if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
-            uploadFileOptions.files.push({
-              name: 'files',
-              filename: 'SELFIE_IMAGE.jpg',
-              filepath: decodeURIComponent(`${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`),
-              filetype: 'image/jpeg'
-            });
-          }
         }
       }
-      const livenessVideoPath = livenessDetection.videoPath;
-      if (livenessVideoPath) {
-        let videoFilePath;
-        if (Platform.OS === 'ios') {
-          const tmpTimestamp = new Date().getTime();
-          await RNFS.mkdir(`${RNFS.TemporaryDirectoryPath}/${tmpTimestamp}`);
-          videoFilePath = `${RNFS.TemporaryDirectoryPath}/${tmpTimestamp}/LIVENESS_VIDEO.mp4`;
-        } else {
-          videoFilePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`;
-        }
-        await RNFS.copyFile(livenessVideoPath, videoFilePath);
-
-        // Compress video with maximum compression settings
-        const compressedVideoPath = await VideoCompressor.compress(videoFilePath, {
-          compressionMethod: 'manual',
-          bitrate: 500000,
-          // 500 kbps
-          maxSize: 1280,
-          // HD 720p
-          minimumFileSizeForCompress: 0 // Always compress
-        }, compressionProgress => {
-          // Map compression progress (0-1) to main progress (40-60%)
-          setProgress(40 + compressionProgress * 20);
-        });
-
-        // Convert file:// URI to regular path for RNFS upload
-        const normalizedPath = compressedVideoPath.replace('file://', '');
-        uploadFileOptions.files.push({
-          name: 'files',
-          filename: 'LIVENESS_VIDEO.mp4',
-          filepath: normalizedPath,
-          filetype: 'video/mp4'
-        });
+      if (uploadFileOptions.files.length === 0) {
+        return;
       }
-    }
-    if (uploadFileOptions.files.length === 0) {
-      return;
-    }
-    const response = await RNFS.uploadFiles(uploadFileOptions).promise;
-    if (![200, 201, 204].includes(response.statusCode)) {
-      throw new Error('Media upload failed');
+      const response = await RNFS.uploadFiles(uploadFileOptions).promise;
+      if (![200, 201, 204].includes(response.statusCode)) {
+        throw new Error('Media upload failed');
+      }
+    } finally {
+      await Promise.all(tempPaths.map(path => RNFS.unlink(path).catch(() => {})));
     }
   }, [apiUrl]);
   const uploadVerbalConsentVideos = useCallback(async (identificationId, verbalConsentVideos) => {
@@ -335,11 +327,15 @@ const ResultScreen = () => {
         minimumFileSizeForCompress: 0 // Always compress
       });
       const compressedNormalizedPath = compressedVideoPath.replace('file://', '');
+      const consentSessionToken = getSessionToken();
       const response = await RNFS.uploadFiles({
         toUrl: `${apiUrl}/identifications/${identificationId}/media`,
         method: 'POST',
         headers: {
-          Accept: 'application/json'
+          Accept: 'application/json',
+          ...(consentSessionToken ? {
+            'X-Session-Token': consentSessionToken
+          } : {})
         },
         fields: {
           consentTitle: consentVideo.title,

package/lib/module/Shared/Components/DebugOverlay.js

@@ -518,13 +518,16 @@ export const TestModePanel = /*#__PURE__*/React.memo(function TestModePanel({
         },
         children: [/*#__PURE__*/_jsx(TextView, {
           style: {
-            color: '#FFA500',
+            // Green "GO" header: the panel only ever receives a STABLE + valid
+            // consensus MRZ (the caller withholds it until then), so showing it
+            // here IS the reliable-detection signal.
+            color: '#4CAF50',
             fontSize: 12,
             fontWeight: 'bold',
             marginBottom: 8,
             textAlign: 'center'
           },
-          children: "MRZ Text Read"
+          children: "\u2713 MRZ STABLE \u2014 GO"
         }), /*#__PURE__*/_jsx(TextView, {
           style: {
             color: '#FFFFFF',

package/lib/module/Shared/Components/IdentityDocumentCamera.js

@@ -22,7 +22,7 @@ import { useTheme } from "../Contexts/ThemeContext.js";
 import DebugOverlay, { TestModePanel } from "./DebugOverlay.js";
 import { getStatusMessage, getFrameToScreenTransform, transformBoundsToScreen, getScanAreaBounds, angleBetweenPoints, detectDocumentType, determineDocumentTypeToSet, areMRZFieldsEqual, hasRequiredMRZFields, validateFacePosition } from "./IdentityDocumentCamera.utils.js";
 import { handlePassportFlow, handleIDFrontFlow, handleIDBackFlow, getNextStepAfterHologram } from "./IdentityDocumentCamera.flows.js";
-import { HOLOGRAM_IMAGE_COUNT, HOLOGRAM_DETECTION_THRESHOLD, HOLOGRAM_DETECTION_RETRY_COUNT, HOLOGRAM_CAPTURE_INTERVAL, HOLOGRAM_MAX_FRAMES_WITHOUT_FACE, MIN_BRIGHTNESS_THRESHOLD, MAX_BRIGHTNESS_THRESHOLD, FACE_EDGE_MARGIN_PERCENT, MAX_CONSECUTIVE_QUALITY_FAILURES, REQUIRED_CONSISTENT_MRZ_READS, REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS, SIGNATURE_TEXT_REGEX, MRZ_BLOCK_PATTERN, PASSPORT_MRZ_PATTERN, MIN_CARD_FACE_SIZE_PERCENT } from "./IdentityDocumentCamera.constants.js";
+import { HOLOGRAM_IMAGE_COUNT, HOLOGRAM_DETECTION_THRESHOLD, HOLOGRAM_DETECTION_RETRY_COUNT, HOLOGRAM_CAPTURE_INTERVAL, HOLOGRAM_MAX_FRAMES_WITHOUT_FACE, MIN_BRIGHTNESS_THRESHOLD, MAX_BRIGHTNESS_THRESHOLD, FACE_EDGE_MARGIN_PERCENT, MAX_CONSECUTIVE_QUALITY_FAILURES, REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS, SIGNATURE_TEXT_REGEX, MRZ_BLOCK_PATTERN, PASSPORT_MRZ_PATTERN, MIN_CARD_FACE_SIZE_PERCENT } from "./IdentityDocumentCamera.constants.js";
 
 // Re-export types for backward compatibility
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
@@ -59,6 +59,11 @@ const IdentityDocumentCamera = ({
   const [isFrameBlurry, setIsFrameBlurry] = useState(false);
   const [hasGuideShown, setHasGuideShown] = useState(false);
   const [status, setStatus] = useState('SEARCHING');
+  // True once the multi-frame voted MRZ consensus is STABLE + valid (the same
+  // reading matched across `stabilityTarget` consecutive frames, with a clear
+  // vote margin on contested cells). Drives the green "GO" signal — we never show
+  // green on an early/transient valid read, only on a reliably-detected MRZ.
+  const [mrzReliable, setMrzReliable] = useState(false);
   const [nextStep, setNextStep] = useState('SCAN_ID_FRONT_OR_PASSPORT');
   const [_completedStep, setCompletedStep] = useState(null);
   const [detectedDocumentType, setDetectedDocumentType] = useState('UNKNOWN');
@@ -74,8 +79,11 @@ const IdentityDocumentCamera = ({
   // Multi-frame per-character voting: fuses OCR across frames so a single-frame
   // misread (B↔8, S↔5, <↔K, dropped/inserted digit) is outvoted instead of
   // resetting progress. Drives the same `parsedMRZData`/stability the flow uses.
+  // stabilityTarget: 3 — the voted consensus must read the SAME valid MRZ across
+  // 3 consecutive contributing frames before we accept, so a transient look-alike
+  // misread (e.g. OCR-B "4" vs "A") can never lock in on one or two early frames.
   const mrzAggregator = useRef(new MRZFrameAggregator({
-    stabilityTarget: 2
+    stabilityTarget: 3
   }));
 
   // Document type stability tracking - require consistent detections from good quality frames
@@ -157,6 +165,7 @@ const IdentityDocumentCamera = ({
       lastValidMRZFields.current = null;
       validMRZConsecutiveCount.current = 0;
       mrzAggregator.current.reset();
+      setMrzReliable(false);
       cachedBarcode.current = null;
       isCompletionCallbackInvoked.current = false;
       isStepTransitionInProgress.current = false;
@@ -386,6 +395,7 @@ const IdentityDocumentCamera = ({
       lastValidMRZFields.current = null;
       // New MRZ expected on the back — start voting fresh.
       mrzAggregator.current.reset();
+      setMrzReliable(false);
     }
     validMRZConsecutiveCount.current = 0;
     cachedBarcode.current = null; // Clear cached barcode on step change
@@ -650,15 +660,6 @@ const IdentityDocumentCamera = ({
       // During SCAN_HOLOGRAM, allow processing even if text is not readable
     }
 
-    // Capture test mode data
-    if (testMode && text && text.includes('<')) {
-      const mrzOnlyText = scannedText?.mrzOnlyText || text;
-      setTestModeData({
-        mrzText: mrzOnlyText,
-        timestamp: Date.now()
-      });
-    }
-
     // MRZ stability: require consistent valid reads across frames
     // Skip during SCAN_HOLOGRAM - document type already locked
     const mrzHasRequiredFields = hasRequiredMRZFields(parsedMRZData?.fields);
@@ -674,12 +675,37 @@ const IdentityDocumentCamera = ({
     }
     // else: Invalid/no MRZ - skip frame without resetting (allows temporary OCR noise)
 
-    // Check if we have enough consistent valid reads
-    const mrzStableAndValid =
-    // Either: the multi-frame voted consensus has converged (valid + stable),
-    consensus.stable && parsedMRZData?.valid === true ||
-    // or the legacy N-identical-reads path is satisfied.
-    validMRZConsecutiveCount.current >= REQUIRED_CONSISTENT_MRZ_READS && parsedMRZData?.valid === true && areMRZFieldsEqual(lastValidMRZFields.current, parsedMRZData?.fields);
+    // Accept ONLY when the multi-frame voted consensus is stable.
+    //
+    // Early frames can OCR an ambiguous glyph wrongly yet still produce a
+    // check-digit-VALID reading — e.g. a Turkish document number "A53032352"
+    // misread as "453032352" (the OCR-B 4 looks like A, and 453032352 also
+    // passes its check digit). The old code also accepted on a legacy path of
+    // "N identical valid single-frame reads", which those transient frames
+    // satisfy — locking in the WRONG number before the voted consensus settles
+    // on the correct one. We now require `consensus.stable`: the per-character
+    // vote must be unchanged across `stabilityTarget` consecutive contributing
+    // frames, which is exactly the "only accept once stable" guarantee.
+    // `addFrame` runs for every frame above, so the consensus is always current.
+    const mrzStableAndValid = consensus.stable && parsedMRZData?.valid === true;
+
+    // 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);
+
+    // Test-mode panel: show the MRZ ONLY once it is stable + valid (the same
+    // consensus matched across `stabilityTarget` consecutive frames). Showing
+    // the raw per-frame OCR here would flash transient, possibly mis-converted
+    // readings (e.g. a momentary "4" for "A") before the vote settles — the
+    // opposite of what the screen should convey. We display the corrected,
+    // check-digit-valid consensus and never an unstable intermediate.
+    if (testMode && mrzStableAndValid && mrzText) {
+      setTestModeData(prev => prev?.mrzText === mrzText ? prev : {
+        mrzText,
+        timestamp: Date.now()
+      });
+    }
 
     // ============================================================================
     // SCAN_ID_BACK STEP - Validate MRZ + barcode on back of ID card
@@ -1635,8 +1661,10 @@ const IdentityDocumentCamera = ({
         }), /*#__PURE__*/_jsx(AnimatedText, {
           style: [styles.topZoneText,
           // Priority order for coloring (later styles override earlier ones)
-          // 1. Success (green) - scan completed
-          nextStep === 'COMPLETED' && styles.topZoneTextSuccess,
+          // 1. Success/GO (green) - scan completed OR MRZ reliably detected
+          //    (stable consensus). This is the "GO" signal; never shown on a
+          //    transient/early valid read.
+          (nextStep === 'COMPLETED' || mrzReliable) && styles.topZoneTextSuccess,
           // 2. Error (red) - wrong side - with flash opacity
           status === 'INCORRECT' && styles.topZoneTextError, status === 'INCORRECT' && {
             opacity: errorFlashAnim
@@ -1647,7 +1675,7 @@ const IdentityDocumentCamera = ({
           status === 'SCANNING' && allElementsDetected && elementsOutsideScanArea.length === 0 && !isBrightnessLow && !isFrameBlurry && styles.topZoneTextScanning
           // 5. Default (white) - aligning (not all detected OR elements outside scan area)
           ],
-          children: getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, allElementsDetected, elementsOutsideScanArea, t)
+          children: getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, allElementsDetected, elementsOutsideScanArea, t, mrzReliable)
         })]
       }), /*#__PURE__*/_jsx(View, {
         style: styles.leftZone
@@ -1657,8 +1685,11 @@ const IdentityDocumentCamera = ({
         style: styles.bottomZone
       }), /*#__PURE__*/_jsx(View, {
         style: [styles.scanArea, {
-          borderColor: nextStep === 'COMPLETED' ? '#4CAF50' : status === 'INCORRECT' ? '#f44336' : status === 'SCANNING' ? '#2196F3' : isBrightnessLow || isFrameBlurry ? '#FFC107' : 'white',
-          borderWidth: status === 'SCANNING' ? 3 : 2
+          borderColor:
+          // Green once the scan is done OR the MRZ is reliably detected
+          // (stable consensus) — the "GO" signal. Never green before that.
+          nextStep === 'COMPLETED' || mrzReliable ? '#4CAF50' : status === 'INCORRECT' ? '#f44336' : status === 'SCANNING' ? '#2196F3' : isBrightnessLow || isFrameBlurry ? '#FFC107' : 'white',
+          borderWidth: mrzReliable || status === 'SCANNING' ? 3 : 2
         }],
         children: nextStep === 'COMPLETED' ? /*#__PURE__*/_jsx(LottieView, {
           source: require('../../Shared/Animations/success.json'),

package/lib/module/Shared/Components/IdentityDocumentCamera.utils.js

@@ -78,10 +78,17 @@ export function transformBoundsToScreen(bounds, scale, offsetX, offsetY) {
  * Unified status message logic used by both voice guidance and render text.
  * Returns the appropriate i18n key arguments for the current scan state.
  */
-export function getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, allElementsDetected, elementsOutsideScanArea, t) {
+export function getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, allElementsDetected, elementsOutsideScanArea, t, mrzReliable = false) {
   if (nextStep === 'COMPLETED') {
     return t('identityDocumentCamera.scanCompleted');
   }
+
+  // MRZ reliably detected (stable consensus) — the green "GO" message. Ranks
+  // above the in-progress states so the user gets a clear positive signal the
+  // moment the reading has settled, but never on an early/transient valid read.
+  if (mrzReliable) {
+    return t('identityDocumentCamera.mrzDetected');
+  }
   if (status === 'INCORRECT') {
     if (nextStep === 'SCAN_ID_FRONT_OR_PASSPORT') {
       return t('identityDocumentCamera.alignIDFront');