@trustchex/react-native-sdk 1.475.1 → 1.481.1

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

@@ -0,0 +1,64 @@
+"use strict";
+
+import React, { useState } from 'react';
+import { Alert } from 'react-native';
+import { useTranslation } from 'react-i18next';
+import StyledButton from "./StyledButton.js";
+import { sendDiagnosticReport, isDiagnosticSharingAvailable } from "../Libs/sendDiagnosticReport.js";
+import { SDK_VERSION } from "../../version.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * "Report a scanning issue" button for the result screen.
+ *
+ * Shows a brief notice describing what will be shared (the draft itself is the
+ * user's review/consent step), then opens the OS share sheet — the user picks
+ * email / WhatsApp / Drive / etc. and sends the diagnostic bundle to support.
+ * Self-contained so the result screen only needs to render it with the scan
+ * data + captured images.
+ */
+const DiagnosticReportButton = ({
+  scan,
+  sessionId,
+  images
+}) => {
+  const {
+    t
+  } = useTranslation();
+  const [sending, setSending] = useState(false);
+
+  // `react-native-share` is optional — hide the button entirely when the host
+  // app hasn't installed it, so apps that don't want diagnostics see no UI.
+  if (!isDiagnosticSharingAvailable()) {
+    return null;
+  }
+  const onPress = () => {
+    if (sending) return;
+    // Brief notice — the share draft is the actual review/consent step.
+    Alert.alert(t('diagnosticReport.noticeTitle'), t('diagnosticReport.noticeBody'), [{
+      text: t('diagnosticReport.cancel'),
+      style: 'cancel'
+    }, {
+      text: t('diagnosticReport.continue'),
+      onPress: async () => {
+        setSending(true);
+        try {
+          await sendDiagnosticReport({
+            scan,
+            sdkVersion: SDK_VERSION,
+            sessionId,
+            images
+          });
+        } finally {
+          setSending(false);
+        }
+      }
+    }]);
+  };
+  return /*#__PURE__*/_jsx(StyledButton, {
+    mode: "outlined",
+    onPress: onPress,
+    disabled: sending,
+    children: t('diagnosticReport.button')
+  });
+};
+export default DiagnosticReportButton;

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

@@ -13,6 +13,7 @@ import { useKeepAwake } from "../Libs/native-keep-awake.utils.js";
 import { useIsFocused } from '@react-navigation/native';
 import { useTranslation } from 'react-i18next';
 import { debugLog, logError, isDebugEnabled } from "../Libs/debug.utils.js";
+import { diagnostics } from "../Libs/diagnostics.js";
 import LottieView from 'lottie-react-native';
 import StyledButton from "./StyledButton.js";
 import { SafeAreaView } from 'react-native-safe-area-context';
@@ -22,7 +23,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";
@@ -52,13 +53,31 @@ const IdentityDocumentCamera = ({
   }, []);
   const isCameraInitialized = useRef(false);
   const [currentFaceImage, setCurrentFaceImage] = useState(undefined);
+  // Synchronous mirror of the locked face image (see currentHologramImageRef).
+  // Used as a fallback when completing SCAN_HOLOGRAM: the torch is on during
+  // hologram capture so the live frame's face is often rejected, leaving the
+  // state-derived faceImageToUse null within the stale closure — without this
+  // the completion gate's `&& !!faceImageToUse` would never pass.
+  const currentFaceImageRef = useRef(undefined);
   const [_currentHologramMaskImage, setCurrentHologramMaskImage] = useState(undefined);
   const [currentHologramImage, setCurrentHologramImage] = useState(undefined);
+  // Mirror of currentHologramImage for synchronous reads inside the per-frame
+  // callback. The setState above is async and currentHologramImage is a
+  // useCallback dependency, so frames processed before React re-renders the
+  // closure would otherwise still see the old (undefined) value — causing the
+  // SCAN_HOLOGRAM step to re-collect faces forever and never complete after a
+  // successful detection. Always keep this ref in lockstep with the state.
+  const currentHologramImageRef = useRef(undefined);
   const [currentSecondaryFaceImage, setCurrentSecondaryFaceImage] = useState(undefined);
   const [isBrightnessLow, setIsBrightnessLow] = useState(false);
   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 +93,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
@@ -102,10 +124,28 @@ const IdentityDocumentCamera = ({
   const isHologramDetectionInProgress = useRef(false); // Prevent concurrent hologram detection calls
   const isCompletionCallbackInvoked = useRef(false); // Prevent multiple callback invocations when COMPLETED
   const isStepTransitionInProgress = useRef(false); // Prevent duplicate step transitions from rapid frames
+  // The step a transition is currently in progress FROM. The latch above is
+  // reset asynchronously (via a nextStep effect), so in fast flows (e.g. demo
+  // mode auto-advancing) a later transition from a DIFFERENT step could be
+  // wrongly blocked while the latch is still set for the previous step. Gating
+  // on the originating step lets a genuine next-step transition through while
+  // still de-duping rapid repeat frames of the SAME transition.
+  const stepTransitionFrom = useRef(null);
   const isCompletionAnnouncementSpoken = useRef(false); // Prevent duplicate "scan completed" voice guidance
 
   const faceDetectionErrorCount = useRef(0);
   const brightnessHistory = useRef([]);
+  // Running camera-quality stats for the support diagnostic report.
+  const diagStats = useRef({
+    frames: 0,
+    brightnessSum: 0,
+    minBrightness: 255,
+    maxBrightness: 0,
+    frameW: 0,
+    frameH: 0,
+    hadLowBrightness: false,
+    hadBlurryFrames: false
+  });
   const [faceDetectionEnabled, setFaceDetectionEnabled] = useState(true);
   const faceImages = useRef([]);
   const hologramImageCountRef = useRef(0);
@@ -143,6 +183,7 @@ const IdentityDocumentCamera = ({
       setIsActive(true);
       isCompletionCallbackInvoked.current = false; // Reset callback flag when starting new scan
       isStepTransitionInProgress.current = false;
+      stepTransitionFrom.current = null;
       isCompletionAnnouncementSpoken.current = false;
     } else {
       setIsActive(false);
@@ -157,12 +198,28 @@ const IdentityDocumentCamera = ({
       lastValidMRZFields.current = null;
       validMRZConsecutiveCount.current = 0;
       mrzAggregator.current.reset();
+      setMrzReliable(false);
+      // Start a fresh diagnostics session for the support report.
+      diagnostics.reset(Date.now());
+      diagStats.current = {
+        frames: 0,
+        brightnessSum: 0,
+        minBrightness: 255,
+        maxBrightness: 0,
+        frameW: 0,
+        frameH: 0,
+        hadLowBrightness: false,
+        hadBlurryFrames: false
+      };
       cachedBarcode.current = null;
       isCompletionCallbackInvoked.current = false;
       isStepTransitionInProgress.current = false;
+      stepTransitionFrom.current = null;
       isCompletionAnnouncementSpoken.current = false;
       // Clear all captured image states from previous scan
+      currentFaceImageRef.current = undefined;
       setCurrentFaceImage(undefined);
+      currentHologramImageRef.current = undefined;
       setCurrentHologramImage(undefined);
       setCurrentSecondaryFaceImage(undefined);
       resetLastMessage();
@@ -175,9 +232,12 @@ const IdentityDocumentCamera = ({
       setLatestHologramFaceImage(undefined);
       isCompletionCallbackInvoked.current = false; // Reset callback flag on unmount
       isStepTransitionInProgress.current = false;
+      stepTransitionFrom.current = null;
       isCompletionAnnouncementSpoken.current = false;
       // Clear all captured image states on unmount
+      currentFaceImageRef.current = undefined;
       setCurrentFaceImage(undefined);
+      currentHologramImageRef.current = undefined;
       setCurrentHologramImage(undefined);
       setCurrentSecondaryFaceImage(undefined);
       resetLastMessage();
@@ -223,6 +283,7 @@ const IdentityDocumentCamera = ({
       isCompletionCallbackInvoked.current = false;
     }
     isStepTransitionInProgress.current = false;
+    stepTransitionFrom.current = null;
   }, [nextStep]);
 
   // Update status bar based on guide visibility
@@ -356,6 +417,7 @@ const IdentityDocumentCamera = ({
         setHologramImageCount(0);
         setLatestHologramFaceImage(undefined);
         // Clear previous hologram state to prevent premature completion
+        currentHologramImageRef.current = undefined;
         setCurrentHologramImage(undefined);
         setCurrentHologramMaskImage(undefined);
       }
@@ -386,6 +448,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
@@ -398,10 +461,14 @@ const IdentityDocumentCamera = ({
     }
   }, [setIsTorchOn]);
   const transitionStepWithCallback = useCallback((nextStepType, fromStep, scannedData) => {
-    if (isStepTransitionInProgress.current) {
+    // De-dupe only rapid repeat frames of the SAME originating step. A
+    // transition from a different step is a genuine advance (the async latch
+    // reset may not have run yet in fast flows like demo mode), so allow it.
+    if (isStepTransitionInProgress.current && stepTransitionFrom.current === fromStep) {
       return;
     }
     isStepTransitionInProgress.current = true;
+    stepTransitionFrom.current = fromStep;
 
     // Torch only needed during SCAN_HOLOGRAM - turn off for all other transitions
     if (nextStepType !== 'SCAN_HOLOGRAM') {
@@ -557,9 +624,30 @@ const IdentityDocumentCamera = ({
     // of letting one noisy frame reset progress.
     const mrzBandHeight = scannedText?.blocks?.length ? Math.max(0, ...scannedText.blocks.map(b => b.blockFrame?.height ?? 0)) : 0;
     const frameWeight = mrzBandHeight > 0 ? mrzBandHeight : 1;
+    // ML Kit per-symbol confidence over MRZ characters (Android bundled library
+    // only; undefined on iOS). When present it down-weights frames the
+    // recognizer was unsure about, so a confident frame outvotes a shaky one of
+    // the same band height on look-alike ties (A↔4, S↔5, B↔8).
+    const frameConfidence = scannedText?.textConfidence?.mean;
     const consensus = mrzAggregator.current.addFrame({
       text: textForValidation,
-      weight: frameWeight
+      weight: frameWeight,
+      confidence: frameConfidence
+    });
+
+    // Record MRZ consensus metrics for the support diagnostic report (counts
+    // and pass/fail only — never the MRZ values themselves). `reachedStable`
+    // is sticky in the collector, so a later flicker can't unset it.
+    // `stabilityFrames`/`minContestedMargin` and the MRZ band pixel height are
+    // device-variance signals (convergence speed, look-alike resolution
+    // confidence, and whether the band cleared the ~16px/char OCR floor).
+    diagnostics.setMrz({
+      framesProcessed: consensus.frames,
+      reachedStable: consensus.stable,
+      format: consensus.validation?.format ?? undefined,
+      stabilityFrames: consensus.stableStreak,
+      minContestedMargin: Number.isFinite(consensus.minContestedMargin) ? consensus.minContestedMargin : 0,
+      maxMrzBandHeightPx: mrzBandHeight
     });
 
     // Use the fused consensus when it is valid; otherwise fall back to a
@@ -583,6 +671,9 @@ const IdentityDocumentCamera = ({
     // be wrong (ID_FRONT locked before passport MRZ became readable)
     const documentType = nextStep === 'SCAN_ID_FRONT_OR_PASSPORT' ? detectDocumentType(primaryFaces, text, parsedMRZData?.fields, frameWidth, mrzText) : parsedMRZData?.fields?.documentCode === 'P' ? 'PASSPORT' : detectedDocumentType;
 
+    // Record the detected document type for the diagnostic report.
+    if (documentType) diagnostics.setDocument(documentType);
+
     // Crop faces once document type is confirmed or we're past the initial step
     const shouldCropFaces = documentType === 'ID_FRONT' || documentType === 'PASSPORT' || nextStep !== 'SCAN_ID_FRONT_OR_PASSPORT';
     const croppedFaces = shouldCropFaces ? await getFaceImages(primaryFaces, image ?? '', frameWidth, frameHeight) : [];
@@ -636,6 +727,7 @@ const IdentityDocumentCamera = ({
         // Continue scanning without locking this face
       } else {
         faceImageToUse = croppedFaces[0];
+        currentFaceImageRef.current = croppedFaces[0];
         setCurrentFaceImage(croppedFaces[0]);
       }
     }
@@ -650,15 +742,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 +757,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
@@ -834,8 +942,8 @@ const IdentityDocumentCamera = ({
         // Skip face position validation for hologram — flash toggling causes position jitter
         if (primaryFaceOnly) {
           hologramFramesWithoutFace.current = 0;
-          if (currentHologramImage) {
-            scannedData.hologramImage = currentHologramImage;
+          if (currentHologramImageRef.current) {
+            scannedData.hologramImage = currentHologramImageRef.current;
           } else if (faceImages.current.length < HOLOGRAM_IMAGE_COUNT) {
             // Space out captures for better variation
             const timeSinceLastCapture = Date.now() - lastHologramCaptureTime.current;
@@ -895,6 +1003,7 @@ const IdentityDocumentCamera = ({
               if (hologram) {
                 setCurrentHologramMaskImage(hologramMask);
                 scannedData.hologramImage = hologram;
+                currentHologramImageRef.current = hologram;
                 setCurrentHologramImage(hologram);
                 if (isDebugEnabled()) {
                   debugLog('IdentityDocumentCamera', '[Hologram] ✓ Saved hologram image');
@@ -920,8 +1029,8 @@ const IdentityDocumentCamera = ({
         } else {
           hologramFramesWithoutFace.current++;
         }
-      } else if (currentHologramImage) {
-        scannedData.hologramImage = currentHologramImage;
+      } else if (currentHologramImageRef.current) {
+        scannedData.hologramImage = currentHologramImageRef.current;
       }
 
       // Secondary face capture (continuous during initial scan and hologram detection)
@@ -1055,10 +1164,20 @@ const IdentityDocumentCamera = ({
         return;
       }
 
-      // Complete when hologram captured OR retries exhausted (not mid-collection)
-      const stepComplete = (!!scannedData.hologramImage || maxRetriesReached && !isCollecting) && !!faceImageToUse; // Require face before completing
+      // Complete when hologram captured OR retries exhausted (not mid-collection).
+      // Fall back to the previously locked face (ref) when the live frame's face
+      // was rejected — the torch is on during hologram capture, so faceImageToUse
+      // is frequently null even though a valid face was locked during the front
+      // scan. Without this the gate's face requirement could never be satisfied.
+      const faceForCompletion = faceImageToUse ?? currentFaceImageRef.current;
+      const stepComplete = (!!scannedData.hologramImage || maxRetriesReached && !isCollecting) && !!faceForCompletion; // Require face before completing
 
       if (stepComplete) {
+        // Make sure the locked face rides along even if this frame's face was
+        // rejected.
+        if (!scannedData.faceImage && faceForCompletion) {
+          scannedData.faceImage = faceForCompletion;
+        }
         // Ensure preserved MRZ data is included (current frame may not have
         // readable MRZ due to flash/tilting during hologram capture)
         if (!scannedData.mrzText && lastValidMRZText.current) {
@@ -1170,6 +1289,15 @@ const IdentityDocumentCamera = ({
       brightnessHistory.current.shift();
     }
     const avgBrightness = brightnessHistory.current.reduce((a, b) => a + b, 0) / brightnessHistory.current.length;
+
+    // Accumulate camera diagnostics (frame count, brightness range, dims) for
+    // the support diagnostic report. Cheap, side-effect-only.
+    diagStats.current.frames += 1;
+    diagStats.current.brightnessSum += frameBrightness;
+    diagStats.current.minBrightness = Math.min(diagStats.current.minBrightness, frameBrightness);
+    diagStats.current.maxBrightness = Math.max(diagStats.current.maxBrightness, frameBrightness);
+    diagStats.current.frameW = frame.width ?? diagStats.current.frameW;
+    diagStats.current.frameH = frame.height ?? diagStats.current.frameH;
     const isOverallBright = avgBrightness >= MIN_BRIGHTNESS_THRESHOLD;
 
     // Check brightness in center region (area of interest)
@@ -1180,6 +1308,7 @@ const IdentityDocumentCamera = ({
       isRegionBright = isOverallBright;
     }
     setIsBrightnessLow(!isRegionBright);
+    if (!isRegionBright) diagStats.current.hadLowBrightness = true;
 
     // Check blur only in center region (area of interest) to avoid false positives
     // from iOS depth-of-field background blur
@@ -1200,10 +1329,30 @@ const IdentityDocumentCamera = ({
       );
       isNotBlurry = !isBlurry;
       setIsFrameBlurry(isBlurry);
+      if (isBlurry) diagStats.current.hadBlurryFrames = true;
     } catch (error) {
       setIsFrameBlurry(false);
     }
 
+    // Flush accumulated camera stats into the diagnostics collector.
+    const ds = diagStats.current;
+    diagnostics.setCamera({
+      frames: ds.frames,
+      frameW: ds.frameW,
+      frameH: ds.frameH,
+      avgBrightness: ds.frames > 0 ? Math.round(ds.brightnessSum / ds.frames) : 0,
+      minBrightness: ds.minBrightness === 255 && ds.frames === 0 ? 0 : ds.minBrightness,
+      maxBrightness: ds.maxBrightness,
+      hadLowBrightness: ds.hadLowBrightness,
+      hadBlurryFrames: ds.hadBlurryFrames,
+      // The actual gates the measured values are judged against — lets support
+      // read "measured 45 vs floor 45" instead of just a pass/fail flag.
+      thresholds: {
+        minBrightness: MIN_BRIGHTNESS_THRESHOLD,
+        blur: 50
+      }
+    });
+
     // Only proceed if image quality is acceptable
     const hasAcceptableQuality = isRegionBright && isNotBlurry;
 
@@ -1248,6 +1397,7 @@ const IdentityDocumentCamera = ({
         resultText,
         mrzOnlyText: undefined,
         // Will be set below if MRZ blocks detected
+        textConfidence: frame.textConfidence,
         blocks: textBlocks.map(block => ({
           blockText: block.text || '',
           blockFrame: block.blockFrame ?? {
@@ -1635,8 +1785,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 +1799,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 +1809,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');

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

@@ -5,7 +5,6 @@ import AppContext from "../Contexts/AppContext.js";
 import { CommonActions, useNavigation, usePreventRemove } from '@react-navigation/native';
 import { View, StyleSheet, Alert } from 'react-native';
 import { useTranslation } from 'react-i18next';
-import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import i18n from "../../Translation/index.js";
 import StyledButton from "./StyledButton.js";
 import { analyticsService } from "../Services/AnalyticsService.js";
@@ -26,7 +25,6 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
   const {
     t
   } = useTranslation();
-  const insets = useSafeAreaInsets();
   const routes = {
     VERIFICATION_SESSION_CHECK: 'VerificationSessionCheckScreen',
     DYNAMIC_ROUTES: {
@@ -185,9 +183,7 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
     allowSkipStep: appContext.currentWorkflowStep?.required
   }));
   return appContext.currentWorkflowStep && (!appContext.currentWorkflowStep?.required || canSkipStep) && /*#__PURE__*/_jsx(View, {
-    style: [styles.container, {
-      paddingBottom: insets.bottom
-    }],
+    style: styles.container,
     children: /*#__PURE__*/_jsx(StyledButton, {
       mode: "text",
       onPress: goToNextRouteWithAlert,
@@ -196,11 +192,13 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
   });
 });
 const styles = StyleSheet.create({
+  // Hug the text button: centered, minimal padding, no full-width opaque bar so
+  // it occupies the least area and never overlays sibling content. The screen's
+  // footer wrapper already applies the bottom safe-area inset.
   container: {
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 20,
-    backgroundColor: 'white'
+    alignSelf: 'center',
+    paddingHorizontal: 16,
+    paddingVertical: 8
   }
 });
 export default NavigationManager;