@trustchex/react-native-sdk 1.478.7 → 1.481.1

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

@@ -40,6 +40,7 @@ import com.google.mlkit.vision.text.TextRecognition
 import com.google.mlkit.vision.text.latin.TextRecognizerOptions
 import java.io.ByteArrayOutputStream
 import kotlin.math.max
+import kotlin.math.min
 import java.io.File
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
@@ -524,8 +525,35 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
                             val result = textTask.result
                             frameData.putString("resultText", result.text)
 
+                            // Per-symbol confidence aggregation (ML Kit BUNDLED library
+                            // only — Text.Symbol.confidence is 0 on the unbundled
+                            // play-services variant). We walk Block→Line→Element→Symbol
+                            // and accumulate confidence over MRZ-shaped characters
+                            // ([A-Z0-9<]) only, so surrounding non-MRZ text doesn't skew
+                            // the weight. The mean and min are surfaced to JS as a
+                            // per-frame quality signal that down-weights low-confidence
+                            // frames in the multi-frame vote.
+                            var confSum = 0f
+                            var confCount = 0
+                            var confMin = 1f
+
                             val blocksArray = Arguments.createArray()
                             for (block in result.textBlocks) {
+                                for (line in block.lines) {
+                                    for (element in line.elements) {
+                                        for (symbol in element.symbols) {
+                                            val ch = symbol.text.firstOrNull() ?: continue
+                                            val upper = ch.uppercaseChar()
+                                            val isMrzChar = upper in 'A'..'Z' ||
+                                                upper in '0'..'9' || upper == '<'
+                                            if (!isMrzChar) continue
+                                            val c = symbol.confidence ?: continue
+                                            confSum += c
+                                            confCount++
+                                            if (c < confMin) confMin = c
+                                        }
+                                    }
+                                }
                                 val blockMap = Arguments.createMap()
                                 blockMap.putString("text", block.text)
                                 val bb = block.boundingBox
@@ -552,6 +580,17 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
                                 blocksArray.pushMap(blockMap)
                             }
                             frameData.putArray("textBlocks", blocksArray)
+
+                            // Frame-level MRZ-character confidence (mean + min over MRZ
+                            // symbols). Omitted when ML Kit returned no usable confidence
+                            // (count == 0) so JS can fall back to band-height weighting.
+                            if (confCount > 0) {
+                                val confMap = Arguments.createMap()
+                                confMap.putDouble("mean", (confSum / confCount).toDouble())
+                                confMap.putDouble("min", confMin.toDouble())
+                                confMap.putInt("count", confCount)
+                                frameData.putMap("textConfidence", confMap)
+                            }
                         } else {
                             frameData.putString("resultText", "")
                             frameData.putArray("textBlocks", Arguments.createArray())
@@ -1085,11 +1124,26 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
             full.recycle()
 
             // Upscale so a ~30–44-char MRZ line clears the per-character pixel
-            // minimum. Cap the long edge to keep OCR latency bounded.
+            // minimum — but NO FURTHER. ML Kit gains no accuracy above ~24px per
+            // character (Google's guidance), and upscaling past that only adds
+            // interpolation artifacts and latency. So target ~24px/char and take
+            // the SMALLER of (a) the scale needed to reach that target and (b) the
+            // long-edge/latency cap. When the band is already sharp enough, scale
+            // stays at 1 (skip upscaling entirely).
             val maxLongEdge = 2200
             val longEdge = max(cropW, cropH)
-            val rawScale = if (longEdge > 0) (maxLongEdge.toFloat() / longEdge) else 1f
-            val scale = rawScale.coerceIn(1f, 2.5f)
+            val capScale = if (longEdge > 0) {
+                (maxLongEdge.toFloat() / longEdge).coerceIn(1f, 2.5f)
+            } else 1f
+            // Estimate current glyph height: the MRZ band is up to ~3 text lines
+            // (TD1) within the crop; ~1.4 accounts for line spacing vs glyph height.
+            val mrzBandLines = 3f
+            val targetGlyphPx = 24f
+            val estGlyphPx = (cropH / mrzBandLines) / 1.4f
+            val targetScale = if (estGlyphPx > 0f) {
+                (targetGlyphPx / estGlyphPx).coerceAtLeast(1f)
+            } else capScale
+            val scale = min(targetScale, capScale)
             val outW = (cropW * scale).toInt()
             val outH = (cropH * scale).toInt()
             val scaled = if (scale != 1f) {

package/ios/Camera/TrustchexCameraView.swift

@@ -972,19 +972,14 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
                         blockY = Int(bb.origin.y / roi.scale) + roi.offsetY
                         blockWidth = Int(bb.width / roi.scale)
                         blockHeight = Int(bb.height / roi.scale)
-                    } else if isBufferLandscape {
-                        // Rotate from landscape (1920x1080) to portrait (1080x1920)
-                        // When rotating 90° clockwise (.right):
-                        // new_x = old_y
-                        // new_y = landscape_width - old_x - width
-                        // new_width = old_height
-                        // new_height = old_width
-                        blockX = Int(bb.origin.y)
-                        blockY = pixelWidth - Int(bb.origin.x) - Int(bb.width)
-                        blockWidth = Int(bb.height)
-                        blockHeight = Int(bb.width)
                     } else {
-                        // Already portrait, use directly
+                        // Fallback when the ROI couldn't be built: OCR ran on
+                        // `visionImage`, which is created from `orientedImage` — already
+                        // rotated to portrait (.right applied above when the buffer was
+                        // landscape) with VisionImage.orientation = .up. ML Kit therefore
+                        // returns coordinates in PORTRAIT space already, so they are used
+                        // directly. (A prior landscape→portrait rotation here was a
+                        // double-rotation bug, since the image was no longer landscape.)
                         blockX = Int(bb.origin.x)
                         blockY = Int(bb.origin.y)
                         blockWidth = Int(bb.width)
@@ -1091,10 +1086,20 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         // Move the crop origin to (0,0) so downstream extents are simple.
         img = img.transformed(by: CGAffineTransform(translationX: -cropRect.origin.x, y: -cropRect.origin.y))
 
-        // Upscale (≤2.5×, long edge capped at 2200) for more pixels per character.
+        // Upscale for more pixels per character, but only up to ~24px/char — ML Kit
+        // gains no accuracy above that (Google's guidance), and scaling further only
+        // adds interpolation artifacts and latency. Take the SMALLER of the scale
+        // needed to reach the target glyph height and the long-edge/latency cap; a
+        // band that's already sharp enough stays at scale 1 (no upscaling).
         let longEdge = max(cropW, cropH)
-        let rawScale = longEdge > 0 ? (2200.0 / longEdge) : 1.0
-        let scale = min(max(rawScale, 1.0), 2.5)
+        let capScale = longEdge > 0 ? min(max(2200.0 / longEdge, 1.0), 2.5) : 1.0
+        // MRZ band is up to ~3 text lines (TD1) within the crop; ~1.4 accounts for
+        // line spacing vs glyph height.
+        let mrzBandLines: CGFloat = 3.0
+        let targetGlyphPx: CGFloat = 24.0
+        let estGlyphPx = (cropH / mrzBandLines) / 1.4
+        let targetScale = estGlyphPx > 0 ? max(targetGlyphPx / estGlyphPx, 1.0) : capScale
+        let scale = min(targetScale, capScale)
         if scale != 1.0 {
             img = img.transformed(by: CGAffineTransform(scaleX: scale, y: scale))
         }

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

@@ -18,7 +18,33 @@ import { Video as VideoCompressor } from 'react-native-compressor';
 import { encryptWithAes, getSessionKey } from "../../Shared/Libs/crypto.utils.js";
 import Video from 'react-native-video';
 import StyledButton from "../../Shared/Components/StyledButton.js";
+import DiagnosticReportButton from "../../Shared/Components/DiagnosticReportButton.js";
 import NativeDeviceInfo from "../../Shared/Libs/native-device-info.utils.js";
+
+/**
+ * Collect the captured document/face images (base64) as attachments for a
+ * diagnostic report. On an ID card the BACK image is the MRZ side; on a passport
+ * the front carries the MRZ. The NFC chip face arrives as `faceImage` with its
+ * own mime type, which may be png.
+ */
+const collectDiagnosticImages = doc => {
+  if (!doc) return [];
+  const out = [];
+  const push = (name, b64, mime = 'jpg') => {
+    if (b64 && b64 !== '') out.push({
+      name,
+      base64: b64,
+      mime
+    });
+  };
+  push('mrz-side', doc.backImage);
+  push('front', doc.frontImage);
+  const faceMime = doc.faceImageMimeType === 'image/png' ? 'png' : 'jpg';
+  push('face', doc.faceImage, faceMime);
+  push('secondary-face', doc.secondaryFaceImage);
+  push('hologram', doc.hologramImage);
+  return out;
+};
 import { trackError, trackFunnelStep, useScreenTracking } from "../../Shared/Libs/analytics.utils.js";
 import { analyticsService } from "../../Shared/Services/AnalyticsService.js";
 import { AnalyticsEventName, AnalyticsEventCategory } from "../../Shared/Types/analytics.types.js";
@@ -711,18 +737,28 @@ const ResultScreen = () => {
               }, `${consentVideo.videoPath}-${index}`))]
             })]
           })
-        }), /*#__PURE__*/_jsx(View, {
-          style: {
-            paddingBottom: insets.bottom
-          },
-          children: /*#__PURE__*/_jsx(StyledButton, {
+        }), /*#__PURE__*/_jsxs(View, {
+          style: [styles.footer, {
+            paddingBottom: insets.bottom + 20
+          }],
+          children: [/*#__PURE__*/_jsx(StyledButton, {
             mode: "contained",
             onPress: () => {
               appContext.onCompleted?.();
               navigationManagerRef.current?.reset();
             },
             children: t('resultScreen.demoStartOver')
-          })
+          }), /*#__PURE__*/_jsx(DiagnosticReportButton, {
+            sessionId: appContext.identificationInfo?.sessionId,
+            scan: {
+              documentType: appContext.identificationInfo?.scannedDocument?.documentType,
+              dataSource: appContext.identificationInfo?.scannedDocument?.dataSource,
+              mrzText: appContext.identificationInfo?.scannedDocument?.mrzText,
+              mrzFields: appContext.identificationInfo?.scannedDocument?.mrzFields,
+              barcodeValue: appContext.identificationInfo?.scannedDocument?.barcodeValue
+            },
+            images: collectDiagnosticImages(appContext.identificationInfo?.scannedDocument)
+          })]
         })]
       }) : /*#__PURE__*/_jsxs(_Fragment, {
         children: [/*#__PURE__*/_jsx(LottieView, {

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';
@@ -52,8 +53,21 @@ 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);
@@ -110,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);
@@ -151,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);
@@ -166,12 +199,27 @@ const IdentityDocumentCamera = ({
       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();
@@ -184,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();
@@ -232,6 +283,7 @@ const IdentityDocumentCamera = ({
       isCompletionCallbackInvoked.current = false;
     }
     isStepTransitionInProgress.current = false;
+    stepTransitionFrom.current = null;
   }, [nextStep]);
 
   // Update status bar based on guide visibility
@@ -365,6 +417,7 @@ const IdentityDocumentCamera = ({
         setHologramImageCount(0);
         setLatestHologramFaceImage(undefined);
         // Clear previous hologram state to prevent premature completion
+        currentHologramImageRef.current = undefined;
         setCurrentHologramImage(undefined);
         setCurrentHologramMaskImage(undefined);
       }
@@ -408,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') {
@@ -567,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
@@ -593,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) : [];
@@ -646,6 +727,7 @@ const IdentityDocumentCamera = ({
         // Continue scanning without locking this face
       } else {
         faceImageToUse = croppedFaces[0];
+        currentFaceImageRef.current = croppedFaces[0];
         setCurrentFaceImage(croppedFaces[0]);
       }
     }
@@ -860,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;
@@ -921,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');
@@ -946,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)
@@ -1081,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) {
@@ -1196,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)
@@ -1206,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
@@ -1226,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;
 
@@ -1274,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 ?? {

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;