@trustchex/react-native-sdk 1.475.1 → 1.481.1

package/src/Shared/Components/IdentityDocumentCamera.tsx

@@ -28,6 +28,7 @@ import { useKeepAwake } from '../Libs/native-keep-awake.utils';
 import { useIsFocused } from '@react-navigation/native';
 import { useTranslation } from 'react-i18next';
 import { debugLog, logError, isDebugEnabled } from '../Libs/debug.utils';
+import { diagnostics } from '../Libs/diagnostics';
 import LottieView from 'lottie-react-native';
 import StyledButton from './StyledButton';
 import { SafeAreaView } from 'react-native-safe-area-context';
@@ -112,12 +113,25 @@ const IdentityDocumentCamera = ({
   const [currentFaceImage, setCurrentFaceImage] = useState<string | undefined>(
     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<string | undefined>(undefined);
   const [_currentHologramMaskImage, setCurrentHologramMaskImage] = useState<
     string | undefined
   >(undefined);
   const [currentHologramImage, setCurrentHologramImage] = useState<
     string | undefined
   >(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<string | undefined>(undefined);
   const [currentSecondaryFaceImage, setCurrentSecondaryFaceImage] = useState<
     string | undefined
   >(undefined);
@@ -127,6 +141,11 @@ const IdentityDocumentCamera = ({
   const [status, setStatus] = useState<
     'SEARCHING' | 'SCANNING' | 'SCANNED' | 'INCORRECT'
   >('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' | 'SCAN_ID_BACK' | 'SCAN_HOLOGRAM' | 'COMPLETED'
   >('SCAN_ID_FRONT_OR_PASSPORT');
@@ -148,7 +167,10 @@ 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.
-  const mrzAggregator = useRef(new MRZFrameAggregator({ stabilityTarget: 2 }));
+  // 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: 3 }));
 
   // Document type stability tracking - require consistent detections from good quality frames
   const lastDetectedDocType = useRef<
@@ -180,10 +202,30 @@ 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<
+    'SCAN_ID_FRONT_OR_PASSPORT' | 'SCAN_ID_BACK' | 'SCAN_HOLOGRAM' | null
+  >(null);
   const isCompletionAnnouncementSpoken = useRef(false); // Prevent duplicate "scan completed" voice guidance
 
   const faceDetectionErrorCount = useRef(0);
   const brightnessHistory = useRef<number[]>([]);
+  // 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<string[]>([]);
   const hologramImageCountRef = useRef(0);
@@ -269,6 +311,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);
@@ -283,12 +326,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();
@@ -302,9 +361,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();
@@ -378,6 +440,7 @@ const IdentityDocumentCamera = ({
       isCompletionCallbackInvoked.current = false;
     }
     isStepTransitionInProgress.current = false;
+    stepTransitionFrom.current = null;
   }, [nextStep]);
 
   // Update status bar based on guide visibility
@@ -578,6 +641,7 @@ const IdentityDocumentCamera = ({
           setHologramImageCount(0);
           setLatestHologramFaceImage(undefined);
           // Clear previous hologram state to prevent premature completion
+          currentHologramImageRef.current = undefined;
           setCurrentHologramImage(undefined);
           setCurrentHologramMaskImage(undefined);
         }
@@ -609,6 +673,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
@@ -633,11 +698,18 @@ const IdentityDocumentCamera = ({
       fromStep: 'SCAN_ID_FRONT_OR_PASSPORT' | 'SCAN_ID_BACK' | 'SCAN_HOLOGRAM',
       scannedData: DocumentScannedData
     ) => {
-      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') {
@@ -870,9 +942,32 @@ const IdentityDocumentCamera = ({
           )
         : 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,
+        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
@@ -912,6 +1007,9 @@ const IdentityDocumentCamera = ({
             ? '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' ||
@@ -995,6 +1093,7 @@ const IdentityDocumentCamera = ({
           // Continue scanning without locking this face
         } else {
           faceImageToUse = croppedFaces[0];
+          currentFaceImageRef.current = croppedFaces[0];
           setCurrentFaceImage(croppedFaces[0]);
         }
       }
@@ -1009,15 +1108,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);
@@ -1041,14 +1131,39 @@ const IdentityDocumentCamera = ({
       }
       // else: Invalid/no MRZ - skip frame without resetting (allows temporary OCR noise)
 
-      // Check if we have enough consistent valid reads
+      // 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 =
-        // 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));
+        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
@@ -1278,8 +1393,8 @@ const IdentityDocumentCamera = ({
           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 =
@@ -1366,6 +1481,7 @@ const IdentityDocumentCamera = ({
                 if (hologram) {
                   setCurrentHologramMaskImage(hologramMask);
                   scannedData.hologramImage = hologram;
+                  currentHologramImageRef.current = hologram;
                   setCurrentHologramImage(hologram);
                   if (isDebugEnabled()) {
                     debugLog(
@@ -1397,8 +1513,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)
@@ -1611,13 +1727,23 @@ const IdentityDocumentCamera = ({
           return;
         }
 
-        // Complete when hologram captured OR retries exhausted (not mid-collection)
+        // 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)) &&
-          !!faceImageToUse; // Require face before completing
+          !!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) {
@@ -1820,6 +1946,21 @@ const IdentityDocumentCamera = ({
       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)
@@ -1838,6 +1979,7 @@ const IdentityDocumentCamera = ({
       }
 
       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
@@ -1856,10 +1998,31 @@ 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;
 
@@ -1908,6 +2071,7 @@ const IdentityDocumentCamera = ({
         const scannedText: BlockText = {
           resultText,
           mrzOnlyText: undefined, // Will be set below if MRZ blocks detected
+          textConfidence: frame.textConfidence,
           blocks: textBlocks.map((block) => ({
             blockText: block.text || '',
             blockFrame: block.blockFrame ?? {
@@ -2430,8 +2594,11 @@ const IdentityDocumentCamera = ({
             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' && {
@@ -2457,7 +2624,8 @@ const IdentityDocumentCamera = ({
               isFrameBlurry,
               allElementsDetected,
               elementsOutsideScanArea,
-              t
+              t,
+              mrzReliable
             )}
           </AnimatedText>
         </View>
@@ -2469,7 +2637,9 @@ const IdentityDocumentCamera = ({
             styles.scanArea,
             {
               borderColor:
-                nextStep === 'COMPLETED'
+                // 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'
@@ -2478,7 +2648,8 @@ const IdentityDocumentCamera = ({
                       : isBrightnessLow || isFrameBlurry
                         ? '#FFC107'
                         : 'white',
-              borderWidth: status === 'SCANNING' ? 3 : 2,
+              borderWidth:
+                mrzReliable || status === 'SCANNING' ? 3 : 2,
             },
           ]}
         >

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

@@ -30,6 +30,12 @@ export type BlockText = {
   blocks: BlocksData[];
   resultText: string;
   mrzOnlyText?: string;
+  /**
+   * Per-frame OCR confidence over MRZ characters from ML Kit per-symbol
+   * confidence (Android bundled library only; undefined on iOS). Feeds the
+   * multi-frame vote weight so low-confidence frames count less.
+   */
+  textConfidence?: { mean: number; min: number; count: number };
 };
 
 export type BlocksData = {

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

@@ -96,12 +96,20 @@ export function getStatusMessage(
   isFrameBlurry: boolean,
   allElementsDetected: boolean,
   elementsOutsideScanArea: string[],
-  t: (key: string, params?: Record<string, unknown>) => string
+  t: (key: string, params?: Record<string, unknown>) => string,
+  mrzReliable: boolean = false
 ): string {
   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/src/Shared/Components/NavigationManager.tsx

@@ -13,7 +13,6 @@ import {
 } 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';
 import StyledButton from './StyledButton';
 import { analyticsService } from '../Services/AnalyticsService';
@@ -37,7 +36,6 @@ const NavigationManager = forwardRef(
     const appContext = useContext(AppContext);
     const navigation = useNavigation();
     const { t } = useTranslation();
-    const insets = useSafeAreaInsets();
 
     const routes = {
       VERIFICATION_SESSION_CHECK: 'VerificationSessionCheckScreen',
@@ -274,7 +272,7 @@ const NavigationManager = forwardRef(
     return (
       appContext.currentWorkflowStep &&
       (!appContext.currentWorkflowStep?.required || canSkipStep) && (
-        <View style={[styles.container, { paddingBottom: insets.bottom }]}>
+        <View style={styles.container}>
           <StyledButton mode="text" onPress={goToNextRouteWithAlert}>
             {t('navigationManager.skipStepLabel')}
           </StyledButton>
@@ -285,11 +283,13 @@ const NavigationManager = 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,
   },
 });
 

package/src/Shared/Components/TrustchexCamera.tsx

@@ -62,6 +62,12 @@ export interface Frame {
   faces?: NativeFace[];
   textBlocks?: NativeTextBlock[];
   resultText?: string;
+  /**
+   * Per-frame OCR confidence over MRZ characters, from ML Kit per-symbol
+   * confidence. Android (bundled ML Kit library) only — iOS ML Kit exposes no
+   * symbol-level confidence, so this is undefined there.
+   */
+  textConfidence?: { mean: number; min: number; count: number };
   barcodes?: NativeBarcode[];
 }