@trustchex/react-native-sdk 1.513.1 → 1.513.3

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

@@ -15,6 +15,15 @@ export const MIN_MLI_FACE_SIZE_PERCENT = 0.01; // MLI (Multi Layer Image): min 1
 export const REQUIRED_CONSISTENT_MRZ_READS = 2;
 export const REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS = 3;
 
+// Frames a check-digit-VALID MRZ consensus must stay UNCHANGED before it is
+// accepted regardless of the per-cell vote-margin ("confident") gate. This
+// unblocks a dense passport MRZ where one stubborn OCR-B look-alike keeps a
+// single cell below the margin threshold forever — the scan would otherwise
+// wedge on "hold steady". Set well above the aggregator's stabilityTarget (3)
+// so the normal confident+stable path handles the common case and this only
+// rescues the persistent-look-alike tail (~1.5s at ~8fps).
+export const MRZ_STREAK_ACCEPT_OVERRIDE = 12;
+
 // After this long on a single scan step without completing it, surface the
 // "Having trouble?" prompt so the user isn't stranded on a live camera with no
 // timeout, retry, or help. Per-step (re-armed on each step transition).

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

@@ -24,7 +24,7 @@ import { useTheme } from "../Contexts/ThemeContext.js";
 import DebugOverlay, { TestModePanel } from "./DebugOverlay.js";
 import { getStatusMessage, getFrameToScreenTransform, transformBoundsToScreen, getScanAreaBounds, angleBetweenPoints, detectDocumentType, determineDocumentTypeToSet, areMRZFieldsEqual, hasRequiredMRZFields, validateFacePosition, isPassportDocumentCode, StableFlag } 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_DOCTYPE_DETECTIONS, HELP_PROMPT_DELAY_MS, SIGNATURE_TEXT_REGEX, MRZ_BLOCK_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, FACE_EDGE_MARGIN_PERCENT, MAX_CONSECUTIVE_QUALITY_FAILURES, REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS, MRZ_STREAK_ACCEPT_OVERRIDE, HELP_PROMPT_DELAY_MS, SIGNATURE_TEXT_REGEX, MRZ_BLOCK_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";
@@ -72,11 +72,6 @@ const IdentityDocumentCamera = ({
   const [currentSecondaryFaceImage, setCurrentSecondaryFaceImage] = useState(undefined);
   const [isBrightnessLow, setIsBrightnessLow] = useState(false);
   const [isFrameBlurry, setIsFrameBlurry] = useState(false);
-  // Glare was being silently rejected (frames dropped with no user feedback), so
-  // a user fighting reflections just saw the scan hang. Surface it so we can show
-  // an actionable "move away from glare" hint. Set at each glare rejection;
-  // cleared when a frame passes the brightness check (a fresh, glare-free frame).
-  const [isGlareDetected, setIsGlareDetected] = useState(false);
   const [hasGuideShown, setHasGuideShown] = useState(false);
   // "Having trouble?" escape: if a scan step doesn't complete within
   // HELP_PROMPT_DELAY_MS the user is otherwise stuck on a live camera forever
@@ -99,7 +94,7 @@ const IdentityDocumentCamera = ({
   const consecutiveQualityFailures = useRef(0);
   const mrzDetectionCurrentRetryCount = useRef(0);
 
-  // Hysteresis for the on-screen quality guidance. Brightness/blur/glare are
+  // Hysteresis for the on-screen quality guidance. Brightness/blur are
   // measured every frame; feeding the raw per-frame booleans straight into
   // state made the guidance strobe (a single blurry hand-shake frame flipped
   // "hold steady" on and off). These smooth each flag: it appears after a few
@@ -108,19 +103,11 @@ const IdentityDocumentCamera = ({
   // problems), clear slow (don't flicker off on one good frame).
   const brightnessLowFlag = useRef(new StableFlag(2, 5));
   const blurryFlag = useRef(new StableFlag(3, 6));
-  const glareFlag = useRef(new StableFlag(2, 5));
-  // Glare is asserted by accept-time helpers that run inside the (separately
-  // scoped) handleFaceAndText callback, so it can't flow through a handler
-  // local. This ref is cleared at the top of each frame and set true if any
-  // glare check in that frame found glare; the handler reads it to feed
-  // `glareFlag`. `hadGlareText` distinguishes "card present but glaring" from
-  // an empty view so the warning only shows over an actual document.
-  const rawGlareRef = useRef(false);
   // Whether a document was visible in the PREVIOUS frame (recognized text,
   // barcode, or face). The quality guidance is stabilized BEFORE the quality
   // gate (so dark/blurry frames — which the gate early-returns on — can still
   // raise their warnings), but document-presence is only known LATER in the
-  // frame, so blur/glare are gated on the previous frame's value. One-frame lag
+  // frame, so blur is gated on the previous frame's value. One-frame lag
   // at ~8fps is imperceptible and the hysteresis smooths it.
   const documentPresentRef = useRef(false);
 
@@ -191,8 +178,7 @@ const IdentityDocumentCamera = ({
     frameW: 0,
     frameH: 0,
     hadLowBrightness: false,
-    hadBlurryFrames: false,
-    hadGlare: false
+    hadBlurryFrames: false
   });
   const [faceDetectionEnabled, setFaceDetectionEnabled] = useState(true);
   const faceImages = useRef([]);
@@ -258,8 +244,7 @@ const IdentityDocumentCamera = ({
         frameW: 0,
         frameH: 0,
         hadLowBrightness: false,
-        hadBlurryFrames: false,
-        hadGlare: false
+        hadBlurryFrames: false
       };
       cachedBarcode.current = null;
       isCompletionCallbackInvoked.current = false;
@@ -295,7 +280,7 @@ const IdentityDocumentCamera = ({
   }, [isFocused, hasPermission, hasGuideShown]);
   useEffect(() => {
     if (!hasGuideShown || !appContext.currentWorkflowStep?.data?.voiceGuidanceActive) return;
-    const message = getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, isGlareDetected, allElementsDetected, elementsOutsideScanArea, t);
+    const message = getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, allElementsDetected, elementsOutsideScanArea, t);
     if (message) {
       if (nextStep === 'COMPLETED') {
         if (isCompletionAnnouncementSpoken.current) {
@@ -308,7 +293,7 @@ const IdentityDocumentCamera = ({
       const shouldBypassInterval = nextStep !== 'COMPLETED';
       speak(message, shouldBypassInterval);
     }
-  }, [appContext.currentWorkflowStep?.data?.voiceGuidanceActive, hasGuideShown, isBrightnessLow, isFrameBlurry, isGlareDetected, nextStep, status, detectedDocumentType, allElementsDetected, elementsOutsideScanArea, t]);
+  }, [appContext.currentWorkflowStep?.data?.voiceGuidanceActive, hasGuideShown, isBrightnessLow, isFrameBlurry, nextStep, status, detectedDocumentType, allElementsDetected, elementsOutsideScanArea, t]);
   useEffect(() => {
     if (status === 'INCORRECT') {
       const timeout = setTimeout(() => {
@@ -436,54 +421,12 @@ const IdentityDocumentCamera = ({
     }
   };
 
-  // Check if face image has glare (brightness exceeds threshold). Also surfaces
-  // the result to `isGlareDetected` so the user gets an actionable hint instead
-  // of a silently-stalled scan.
-  const checkFaceGlare = async faceImage => {
-    try {
-      // Check entire face region for glare
-      const hasGlare = await OpenCVModule.isRectangularRegionBright(faceImage, 0, 0, 100,
-      // Full face width
-      100,
-      // Full face height
-      MAX_BRIGHTNESS_THRESHOLD);
-      // OR-accumulate into the per-frame glare signal (reset at frame top); the
-      // frame handler feeds it through the stabilized UI flag. Also record the
-      // diagnostic.
-      if (hasGlare) {
-        rawGlareRef.current = true;
-        diagStats.current.hadGlare = true;
-      }
-      return hasGlare;
-    } catch (error) {
-      return false; // Assume no glare on error
-    }
-  };
-
   // Check if face is fully visible (not cropped at edges)
   const isFaceFullyVisible = (face, frameWidth, frameHeight) => {
     const margin = FACE_EDGE_MARGIN_PERCENT;
     const bounds = face.bounds;
     return bounds.x >= frameWidth * margin && bounds.y >= frameHeight * margin && bounds.x + bounds.width <= frameWidth * (1 - margin) && bounds.y + bounds.height <= frameHeight * (1 - margin);
   };
-
-  // Check if document image has glare
-  const checkDocumentGlare = async (image, width, height) => {
-    try {
-      // Check center 80% region for glare (document area)
-      const hasGlare = await OpenCVModule.isRectangularRegionBright(image, Math.round(width * 0.1), Math.round(height * 0.1), Math.round(width * 0.8), Math.round(height * 0.8), MAX_BRIGHTNESS_THRESHOLD);
-      // OR-accumulate into the per-frame glare signal (reset at frame top); the
-      // frame handler feeds it through the stabilized UI flag. Also record the
-      // diagnostic.
-      if (hasGlare) {
-        rawGlareRef.current = true;
-        diagStats.current.hadGlare = true;
-      }
-      return hasGlare;
-    } catch (error) {
-      return false;
-    }
-  };
   const setNextStepAndVibrate = useCallback((nextStepType, fromStep) => {
     if (fromStep) {
       setCompletedStep(fromStep);
@@ -550,12 +493,9 @@ const IdentityDocumentCamera = ({
     // carried over from the previous side).
     brightnessLowFlag.current.reset(false);
     blurryFlag.current.reset(false);
-    glareFlag.current.reset(false);
-    rawGlareRef.current = false;
     documentPresentRef.current = false;
     setIsBrightnessLow(false);
     setIsFrameBlurry(false);
-    setIsGlareDetected(false);
     if (nextStepType !== 'COMPLETED') {
       setTimeout(() => {
         setStatus('SEARCHING');
@@ -818,13 +758,11 @@ const IdentityDocumentCamera = ({
     if (shouldCropFaces && croppedFaces.length > 0 && croppedFaces[0] && facePositionValid && !currentFaceImage) {
       // Validate face quality before accepting
       const faceFullyVisible = primaryFaces[0] && isFaceFullyVisible(primaryFaces[0], frameWidth, frameHeight);
-      const hasGlare = await checkFaceGlare(croppedFaces[0]);
-      if (!faceFullyVisible || hasGlare) {
-        // Reject face with glare or partially visible
+      if (!faceFullyVisible) {
+        // Reject partially visible face
         if (isDebugEnabled()) {
           debugLog('IdentityDocumentCamera', '[FACE] Rejected', {
-            fullyVisible: faceFullyVisible,
-            hasGlare
+            fullyVisible: faceFullyVisible
           });
         }
         // Continue scanning without locking this face
@@ -872,7 +810,19 @@ const IdentityDocumentCamera = ({
     // 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;
+    // `consensus.stable` also requires a "confident" vote — every contested
+    // cell's winner must lead by a margin. On a dense TD3 passport MRZ (88
+    // cells) a single stubborn OCR-B look-alike (A↔4, S↔5) can keep one cell
+    // at a 1-vote margin indefinitely, so `stable` never flips and the scan
+    // wedges on "hold steady" — even though the check-digit-VALID consensus
+    // has been UNCHANGED for many frames. Check digits are the real correctness
+    // guarantee; a long unchanged, valid streak is conclusive. So also accept
+    // once a valid consensus has held unchanged for MRZ_STREAK_ACCEPT_OVERRIDE
+    // frames (well above `stabilityTarget`), independent of the margin gate.
+    // Short streaks still require the full confident+stable gate, preserving
+    // the early-misread protection.
+    const mrzValidStreakSettled = parsedMRZData?.valid === true && consensus.stableStreak >= MRZ_STREAK_ACCEPT_OVERRIDE;
+    const mrzStableAndValid = (consensus.stable || mrzValidStreakSettled) && 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.
@@ -940,16 +890,6 @@ const IdentityDocumentCamera = ({
           setStatus(mrzText ? 'SCANNING' : 'SEARCHING');
           return;
         }
-
-        // Check for glare on ID back before accepting
-        const hasGlare = await checkDocumentGlare(image, frameWidth, frameHeight);
-        if (hasGlare) {
-          if (isDebugEnabled()) {
-            debugLog('IdentityDocumentCamera', '[ID_BACK] Rejected - glare detected');
-          }
-          setStatus('SCANNING');
-          return;
-        }
         if (isDebugEnabled()) {
           debugLog('IdentityDocumentCamera', '[ID_BACK] MRZ validated', {
             documentNumber: parsedMRZData?.fields?.documentNumber,
@@ -1071,22 +1011,13 @@ const IdentityDocumentCamera = ({
               if (!isTorchOnRef.current) {
                 setIsTorchOn(true);
               }
-
-              // Check hologram face for glare
-              const hasGlare = await checkFaceGlare(primaryFaceOnly);
-              if (!hasGlare) {
-                faceImages.current.push(primaryFaceOnly);
-                lastHologramCaptureTime.current = Date.now();
-                hologramImageCountRef.current = faceImages.current.length;
-                if (isDebugEnabled()) {
-                  debugLog('IdentityDocumentCamera', '[HOLOGRAM] Frame captured', {
-                    frameIndex: faceImages.current.length - 1,
-                    totalFrames: faceImages.current.length
-                  });
-                }
-              } else if (isDebugEnabled()) {
-                debugLog('IdentityDocumentCamera', '[HOLOGRAM] Rejected glare frame', {
-                  collectedCount: faceImages.current.length
+              faceImages.current.push(primaryFaceOnly);
+              lastHologramCaptureTime.current = Date.now();
+              hologramImageCountRef.current = faceImages.current.length;
+              if (isDebugEnabled()) {
+                debugLog('IdentityDocumentCamera', '[HOLOGRAM] Frame captured', {
+                  frameIndex: faceImages.current.length - 1,
+                  totalFrames: faceImages.current.length
                 });
               }
               if (faceImages.current.length > 0) {
@@ -1356,16 +1287,6 @@ const IdentityDocumentCamera = ({
           continueScanning(true);
           return;
         }
-
-        // Check for glare on passport before accepting
-        const hasGlare = await checkDocumentGlare(image, frameWidth, frameHeight);
-        if (hasGlare) {
-          if (isDebugEnabled()) {
-            debugLog('IdentityDocumentCamera', '[PASSPORT] Rejected - glare detected');
-          }
-          continueScanning(false);
-          return;
-        }
         setDetectedDocumentType('PASSPORT');
         setStatus('SCANNED');
         const nextPassportStep = flowResult.nextAction === 'PROCEED_TO_COMPLETED' ? 'COMPLETED' : 'SCAN_HOLOGRAM';
@@ -1382,16 +1303,6 @@ const IdentityDocumentCamera = ({
           continueScanning(flowResult.nextAction !== 'REJECT_AS_PASSPORT');
           return;
         }
-
-        // Check for glare on ID front before accepting
-        const hasGlare = await checkDocumentGlare(image, frameWidth, frameHeight);
-        if (hasGlare) {
-          if (isDebugEnabled()) {
-            debugLog('IdentityDocumentCamera', '[ID_FRONT] Rejected - glare detected');
-          }
-          continueScanning(false);
-          return;
-        }
         setDetectedDocumentType('ID_FRONT');
         setStatus('SCANNED');
         const nextIdFrontStep = onlyMRZScan ? 'SCAN_ID_BACK' : 'SCAN_HOLOGRAM';
@@ -1460,18 +1371,6 @@ const IdentityDocumentCamera = ({
     const rawBrightnessLow = !isRegionBright;
     if (rawBrightnessLow) diagStats.current.hadLowBrightness = true;
 
-    // Per-frame glare is asserted by the accept-time helpers (checkDocumentGlare
-    // /checkFaceGlare), but those run inside handleFaceAndText which is fired
-    // (async, un-awaited) LATER in this handler — so this frame's glare result
-    // isn't known yet at the stabilization block below. We therefore feed the
-    // stabilizer the PREVIOUS frame's glare signal (captured here before the
-    // reset). At ~8fps the one-frame lag is imperceptible and the hysteresis
-    // smooths it anyway; without this the read would always see false and the
-    // glare warning could never fire. Reset after capturing so a now-clean
-    // view clears (no latch).
-    const prevFrameGlare = rawGlareRef.current;
-    rawGlareRef.current = false;
-
     // Check blur only in center region (area of interest) to avoid false positives
     // from iOS depth-of-field background blur
     let isNotBlurry = true;
@@ -1521,8 +1420,8 @@ const IdentityDocumentCamera = ({
     // MUST run BEFORE the quality-gate early-return below: a dark or blurry
     // frame is exactly what makes hasAcceptableQuality false, so if this ran
     // after the gate the "too dark" / "hold steady" warnings could never
-    // raise (their triggering frames would have already returned). Blur/glare
-    // are gated on document presence; brightness shows regardless, since a
+    // raise (their triggering frames would have already returned). Blur
+    // is gated on document presence; brightness shows regardless, since a
     // dark room is worth flagging before the card is even framed.
     //
     // Presence combines the previous frame's confirmed value (documentPresent-
@@ -1531,13 +1430,12 @@ const IdentityDocumentCamera = ({
     // processing). Without the raw proxy, a document that is blurry/dark from
     // its very first framed moment would keep failing the quality gate and
     // early-returning before documentPresentRef is ever set true — suppressing
-    // its blur/glare hints for ~30 frames. The proxy lets the hint fire on the
+    // its blur hints for ~30 frames. The proxy lets the hint fire on the
     // first framed frame.
     const rawDocumentPresent = (frame.faces?.length ?? 0) > 0 || (frame.textBlocks?.length ?? 0) > 0 || (frame.barcodes?.length ?? 0) > 0;
     const documentWasPresent = documentPresentRef.current || rawDocumentPresent;
     setIsBrightnessLow(brightnessLowFlag.current.push(rawBrightnessLow));
     setIsFrameBlurry(blurryFlag.current.push(documentWasPresent && isBlurry));
-    setIsGlareDetected(glareFlag.current.push(documentWasPresent && prevFrameGlare));
     // -------------------------------------------------------------------
 
     // Store quality metrics in ref for access in handleFaceAndText callback
@@ -1598,6 +1496,24 @@ const IdentityDocumentCamera = ({
         }))
       };
 
+      // Isolate the MRZ text (bottom-of-document blocks matching the MRZ
+      // pattern) and feed ONLY that to the multi-frame consensus. CRITICAL:
+      // this must run for EVERY build, not just debug — the identical logic
+      // used to live only inside an `if (isDebugEnabled())` overlay block, so
+      // in release `mrzOnlyText` was never set and the aggregator fell back to
+      // the FULL OCR text (including the passport header "PASSPORT / TÜR /
+      // REPUBLIC OF…"). That header noise kept the per-character consensus from
+      // ever stabilizing, so a passport wedged on "hold steady" forever in
+      // release while working in debug/example. Passport MRZ sits low on the
+      // page; the `y > bottom-half` filter drops the header/photo-area text.
+      if (textBlocks.length > 0) {
+        const bottomHalf = frame.height * 0.5;
+        const mrzBlocks = textBlocks.filter(block => block.blockFrame && block.blockFrame.y > bottomHalf && MRZ_BLOCK_PATTERN.test(block.text));
+        if (mrzBlocks.length > 0) {
+          scannedText.mrzOnlyText = [...mrzBlocks].sort((a, b) => (a.blockFrame?.y || 0) - (b.blockFrame?.y || 0)).map(b => b.text).join('\n');
+        }
+      }
+
       // Read barcodes directly from native ML Kit results
       let barcodes = [];
       if (frame.barcodes) {
@@ -1979,12 +1895,6 @@ const IdentityDocumentCamera = ({
             current: 3,
             total: 3
           })}` : ''
-        }), nextStep === 'SCAN_HOLOGRAM' && status !== 'SCANNED' && /*#__PURE__*/_jsx(TextView, {
-          style: styles.hologramProgress,
-          children: t('identityDocumentCamera.hologramProgress', {
-            current: hologramImageCount,
-            total: HOLOGRAM_IMAGE_COUNT
-          })
         }), /*#__PURE__*/_jsx(AnimatedText, {
           style: [styles.topZoneText,
           // Priority order for coloring (later styles override earlier ones)
@@ -1997,12 +1907,12 @@ const IdentityDocumentCamera = ({
             opacity: errorFlashAnim
           },
           // 3. Warning (yellow) - quality issues
-          (isBrightnessLow || isFrameBlurry || isGlareDetected) && styles.topZoneTextWarning,
+          (isBrightnessLow || isFrameBlurry) && styles.topZoneTextWarning,
           // 4. Scanning (green) - all elements detected AND inside scan area
-          status === 'SCANNING' && allElementsDetected && elementsOutsideScanArea.length === 0 && !isBrightnessLow && !isFrameBlurry && !isGlareDetected && styles.topZoneTextScanning
+          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, isGlareDetected, allElementsDetected, elementsOutsideScanArea, t)
+          children: getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, allElementsDetected, elementsOutsideScanArea, t)
         })]
       }), /*#__PURE__*/_jsx(View, {
         style: styles.leftZone
@@ -2034,7 +1944,7 @@ const IdentityDocumentCamera = ({
           loop: true,
           autoPlay: true
         }) : null
-      }), isDebugEnabled() && /*#__PURE__*/_jsx(DebugOverlay, {
+      }), __DEV__ && isDebugEnabled() && /*#__PURE__*/_jsx(DebugOverlay, {
         nextStep: nextStep,
         status: status,
         detectedDocumentType: detectedDocumentType,
@@ -2054,7 +1964,7 @@ const IdentityDocumentCamera = ({
         hologramImageCount: hologramImageCount,
         allElementsDetected: allElementsDetected,
         elementsOutsideScanArea: elementsOutsideScanArea
-      }), testMode && testModeData && /*#__PURE__*/_jsx(TestModePanel, {
+      }), __DEV__ && testMode && testModeData && /*#__PURE__*/_jsx(TestModePanel, {
         mrzText: testModeData.mrzText
       }), showHelpPrompt && !helpSheetVisible && nextStep !== 'COMPLETED' && /*#__PURE__*/_jsx(TouchableOpacity, {
         style: styles.helpPrompt,
@@ -2171,13 +2081,6 @@ const styles = StyleSheet.create({
     fontWeight: '500',
     marginBottom: 4
   },
-  hologramProgress: {
-    color: '#4CAF50',
-    fontSize: 14,
-    textAlign: 'center',
-    fontWeight: '600',
-    marginBottom: 4
-  },
   topZoneText: {
     color: 'white',
     fontSize: 20,

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

@@ -147,7 +147,7 @@ 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, isGlareDetected, allElementsDetected, elementsOutsideScanArea, t) {
+export function getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, allElementsDetected, elementsOutsideScanArea, t) {
   if (nextStep === 'COMPLETED') {
     return t('identityDocumentCamera.scanCompleted');
   }
@@ -173,14 +173,6 @@ export function getStatusMessage(nextStep, status, detectedDocumentType, isBrigh
   if (isBrightnessLow) {
     return t('identityDocumentCamera.lowBrightness');
   }
-
-  // Glare is a primary failure mode (reflections off the laminate/photo). It was
-  // previously detected but never communicated, so the scan just appeared to
-  // hang. Tell the user how to fix it. Ranked above blur because a glare hotspot
-  // both blocks acceptance and often reads as a "sharp" (non-blurry) frame.
-  if (isGlareDetected) {
-    return t('identityDocumentCamera.reduceGlare');
-  }
   if (isFrameBlurry) {
     return t('identityDocumentCamera.avoidBlur');
   }

package/lib/module/Translation/Resources/en.js

@@ -182,10 +182,8 @@ export default {
   'identityDocumentCamera.frontSide': 'Front',
   'identityDocumentCamera.backSide': 'Back',
   'identityDocumentCamera.hologramCheck': 'Hologram',
-  'identityDocumentCamera.hologramProgress': 'Capturing hologram… {{current}}/{{total}}',
   'identityDocumentCamera.keepSteady': 'Keep device steady',
   'identityDocumentCamera.avoidBlur': 'Keep device steady',
-  'identityDocumentCamera.reduceGlare': 'Glare detected. Tilt the document or move away from direct light.',
   'identityDocumentCamera.wrongSideFront': 'Show the front side of your document',
   'identityDocumentCamera.wrongSideBack': 'Show the back side of your document',
   'identityDocumentCamera.idCardDetected': 'ID detected',

package/lib/module/Translation/Resources/tr.js

@@ -182,10 +182,8 @@ export default {
   'identityDocumentCamera.frontSide': 'Ön',
   'identityDocumentCamera.backSide': 'Arka',
   'identityDocumentCamera.hologramCheck': 'Hologram',
-  'identityDocumentCamera.hologramProgress': 'Hologram yakalanıyor… {{current}}/{{total}}',
   'identityDocumentCamera.keepSteady': 'Cihazı sabit tutun',
   'identityDocumentCamera.avoidBlur': 'Cihazı sabit tutun',
-  'identityDocumentCamera.reduceGlare': 'Parlama algılandı. Belgeyi hafifçe eğin veya doğrudan ışıktan uzaklaşın.',
   'identityDocumentCamera.wrongSideFront': 'Belgenizin ön yüzünü gösterin',
   'identityDocumentCamera.wrongSideBack': 'Belgenizin arka yüzünü gösterin',
   'identityDocumentCamera.idCardDetected': 'Kimlik kartı algılandı',

package/lib/module/version.js

@@ -2,4 +2,4 @@
 
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.513.1';
+export const SDK_VERSION = '1.513.3';

package/lib/typescript/src/Shared/Components/IdentityDocumentCamera.constants.d.ts

@@ -11,6 +11,7 @@ export declare const MIN_CARD_FACE_SIZE_PERCENT = 0.05;
 export declare const MIN_MLI_FACE_SIZE_PERCENT = 0.01;
 export declare const REQUIRED_CONSISTENT_MRZ_READS = 2;
 export declare const REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS = 3;
+export declare const MRZ_STREAK_ACCEPT_OVERRIDE = 12;
 export declare const HELP_PROMPT_DELAY_MS = 25000;
 export declare const SIGNATURE_REGEX: RegExp;
 export declare const SIGNATURE_TEXT_REGEX: RegExp;

package/lib/typescript/src/Shared/Components/IdentityDocumentCamera.constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IdentityDocumentCamera.constants.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/IdentityDocumentCamera.constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,4BAA4B,OAAO,CAAC;AACjD,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAChD,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,gCAAgC,KAAK,CAAC;AAEnD,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,gCAAgC,KAAK,CAAC;AACnD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAC/C,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,eAAO,MAAM,sCAAsC,IAAI,CAAC;AAKxD,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAE1C,eAAO,MAAM,eAAe,QAAkC,CAAC;AAC/D,eAAO,MAAM,oBAAoB,QAAyB,CAAC;AAC3D,eAAO,MAAM,iBAAiB,QAAsB,CAAC;AASrD,eAAO,MAAM,iBAAiB,QAA+B,CAAC;AAS9D,eAAO,MAAM,oBAAoB,QAAyC,CAAC;AAI3E,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAChD,eAAO,MAAM,sBAAsB;;;;;;;;;;CAUzB,CAAC;AAKX,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,gCAAgC,MAAM,CAAC;AACpD,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAChD,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,mBAAmB,MAAM,CAAC"}
+{"version":3,"file":"IdentityDocumentCamera.constants.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/IdentityDocumentCamera.constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,4BAA4B,OAAO,CAAC;AACjD,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAChD,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,gCAAgC,KAAK,CAAC;AAEnD,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,gCAAgC,KAAK,CAAC;AACnD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAC/C,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,eAAO,MAAM,sCAAsC,IAAI,CAAC;AASxD,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAK7C,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAE1C,eAAO,MAAM,eAAe,QAAkC,CAAC;AAC/D,eAAO,MAAM,oBAAoB,QAAyB,CAAC;AAC3D,eAAO,MAAM,iBAAiB,QAAsB,CAAC;AASrD,eAAO,MAAM,iBAAiB,QAA+B,CAAC;AAS9D,eAAO,MAAM,oBAAoB,QAAyC,CAAC;AAI3E,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAChD,eAAO,MAAM,sBAAsB;;;;;;;;;;CAUzB,CAAC;AAKX,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,gCAAgC,MAAM,CAAC;AACpD,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAChD,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,mBAAmB,MAAM,CAAC"}

package/lib/typescript/src/Shared/Components/IdentityDocumentCamera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IdentityDocumentCamera.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/IdentityDocumentCamera.tsx"],"names":[],"mappings":"AA6EA,OAAO,KAAK,EACV,mBAAmB,EACnB,SAAS,EACT,2BAA2B,EAK5B,MAAM,gCAAgC,CAAC;AAGxC,YAAY,EAAE,mBAAmB,EAAE,SAAS,EAAE,2BAA2B,EAAE,CAAC;AAC5E,YAAY,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAMnE,QAAA,MAAM,sBAAsB,GAAI,uDAI7B,2BAA2B,4CA02F7B,CAAC;AA0LF,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"IdentityDocumentCamera.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/IdentityDocumentCamera.tsx"],"names":[],"mappings":"AA6EA,OAAO,KAAK,EACV,mBAAmB,EACnB,SAAS,EACT,2BAA2B,EAK5B,MAAM,gCAAgC,CAAC;AAGxC,YAAY,EAAE,mBAAmB,EAAE,SAAS,EAAE,2BAA2B,EAAE,CAAC;AAC5E,YAAY,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAMnE,QAAA,MAAM,sBAAsB,GAAI,uDAI7B,2BAA2B,4CA2uF7B,CAAC;AAmLF,eAAe,sBAAsB,CAAC"}

package/lib/typescript/src/Shared/Components/IdentityDocumentCamera.utils.d.ts

@@ -82,7 +82,7 @@ export declare function transformBoundsToScreen(bounds: {
  * Unified status message logic used by both voice guidance and render text.
  * Returns the appropriate i18n key arguments for the current scan state.
  */
-export declare function getStatusMessage(nextStep: ScanStep, status: ScanStatus, detectedDocumentType: DocumentType, isBrightnessLow: boolean, isFrameBlurry: boolean, isGlareDetected: boolean, allElementsDetected: boolean, elementsOutsideScanArea: string[], t: (key: string, params?: Record<string, unknown>) => string): string;
+export declare function getStatusMessage(nextStep: ScanStep, status: ScanStatus, detectedDocumentType: DocumentType, isBrightnessLow: boolean, isFrameBlurry: boolean, allElementsDetected: boolean, elementsOutsideScanArea: string[], t: (key: string, params?: Record<string, unknown>) => string): string;
 /**
  * Calculate angle from two points in degrees
  */

package/lib/typescript/src/Shared/Components/IdentityDocumentCamera.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IdentityDocumentCamera.utils.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/IdentityDocumentCamera.utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"IdentityDocumentCamera.utils.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/IdentityDocumentCamera.utils.ts"],"names":[],"mappings":"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"}

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

@@ -180,10 +180,8 @@ declare const _default: {
     'identityDocumentCamera.frontSide': string;
     'identityDocumentCamera.backSide': string;
     'identityDocumentCamera.hologramCheck': string;
-    'identityDocumentCamera.hologramProgress': string;
     'identityDocumentCamera.keepSteady': string;
     'identityDocumentCamera.avoidBlur': string;
-    'identityDocumentCamera.reduceGlare': string;
     'identityDocumentCamera.wrongSideFront': string;
     'identityDocumentCamera.wrongSideBack': string;
     'identityDocumentCamera.idCardDetected': string;

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

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

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

@@ -180,10 +180,8 @@ declare const _default: {
     'identityDocumentCamera.frontSide': string;
     'identityDocumentCamera.backSide': string;
     'identityDocumentCamera.hologramCheck': string;
-    'identityDocumentCamera.hologramProgress': string;
     'identityDocumentCamera.keepSteady': string;
     'identityDocumentCamera.avoidBlur': string;
-    'identityDocumentCamera.reduceGlare': string;
     'identityDocumentCamera.wrongSideFront': string;
     'identityDocumentCamera.wrongSideBack': string;
     'identityDocumentCamera.idCardDetected': string;

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

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

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

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

package/package.json

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

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

@@ -14,6 +14,15 @@ export const MIN_MLI_FACE_SIZE_PERCENT = 0.01; // MLI (Multi Layer Image): min 1
 export const REQUIRED_CONSISTENT_MRZ_READS = 2;
 export const REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS = 3;
 
+// Frames a check-digit-VALID MRZ consensus must stay UNCHANGED before it is
+// accepted regardless of the per-cell vote-margin ("confident") gate. This
+// unblocks a dense passport MRZ where one stubborn OCR-B look-alike keeps a
+// single cell below the margin threshold forever — the scan would otherwise
+// wedge on "hold steady". Set well above the aggregator's stabilityTarget (3)
+// so the normal confident+stable path handles the common case and this only
+// rescues the persistent-look-alike tail (~1.5s at ~8fps).
+export const MRZ_STREAK_ACCEPT_OVERRIDE = 12;
+
 // After this long on a single scan step without completing it, surface the
 // "Having trouble?" prompt so the user isn't stranded on a live camera with no
 // timeout, retry, or help. Per-step (re-armed on each step transition).

package/src/Shared/Components/IdentityDocumentCamera.tsx

@@ -65,11 +65,11 @@ import {
   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,
+  MRZ_STREAK_ACCEPT_OVERRIDE,
   HELP_PROMPT_DELAY_MS,
   SIGNATURE_TEXT_REGEX,
   MRZ_BLOCK_PATTERN,
@@ -141,11 +141,6 @@ const IdentityDocumentCamera = ({
   >(undefined);
   const [isBrightnessLow, setIsBrightnessLow] = useState(false);
   const [isFrameBlurry, setIsFrameBlurry] = useState(false);
-  // Glare was being silently rejected (frames dropped with no user feedback), so
-  // a user fighting reflections just saw the scan hang. Surface it so we can show
-  // an actionable "move away from glare" hint. Set at each glare rejection;
-  // cleared when a frame passes the brightness check (a fresh, glare-free frame).
-  const [isGlareDetected, setIsGlareDetected] = useState(false);
   const [hasGuideShown, setHasGuideShown] = useState(false);
   // "Having trouble?" escape: if a scan step doesn't complete within
   // HELP_PROMPT_DELAY_MS the user is otherwise stuck on a live camera forever
@@ -176,7 +171,7 @@ const IdentityDocumentCamera = ({
   const consecutiveQualityFailures = useRef(0);
   const mrzDetectionCurrentRetryCount = useRef(0);
 
-  // Hysteresis for the on-screen quality guidance. Brightness/blur/glare are
+  // Hysteresis for the on-screen quality guidance. Brightness/blur are
   // measured every frame; feeding the raw per-frame booleans straight into
   // state made the guidance strobe (a single blurry hand-shake frame flipped
   // "hold steady" on and off). These smooth each flag: it appears after a few
@@ -185,19 +180,11 @@ const IdentityDocumentCamera = ({
   // problems), clear slow (don't flicker off on one good frame).
   const brightnessLowFlag = useRef(new StableFlag(2, 5));
   const blurryFlag = useRef(new StableFlag(3, 6));
-  const glareFlag = useRef(new StableFlag(2, 5));
-  // Glare is asserted by accept-time helpers that run inside the (separately
-  // scoped) handleFaceAndText callback, so it can't flow through a handler
-  // local. This ref is cleared at the top of each frame and set true if any
-  // glare check in that frame found glare; the handler reads it to feed
-  // `glareFlag`. `hadGlareText` distinguishes "card present but glaring" from
-  // an empty view so the warning only shows over an actual document.
-  const rawGlareRef = useRef(false);
   // Whether a document was visible in the PREVIOUS frame (recognized text,
   // barcode, or face). The quality guidance is stabilized BEFORE the quality
   // gate (so dark/blurry frames — which the gate early-returns on — can still
   // raise their warnings), but document-presence is only known LATER in the
-  // frame, so blur/glare are gated on the previous frame's value. One-frame lag
+  // frame, so blur is gated on the previous frame's value. One-frame lag
   // at ~8fps is imperceptible and the hysteresis smooths it.
   const documentPresentRef = useRef(false);
 
@@ -275,7 +262,6 @@ const IdentityDocumentCamera = ({
     frameH: 0,
     hadLowBrightness: false,
     hadBlurryFrames: false,
-    hadGlare: false,
   });
   const [faceDetectionEnabled, setFaceDetectionEnabled] = useState(true);
   const faceImages = useRef<string[]>([]);
@@ -390,7 +376,6 @@ const IdentityDocumentCamera = ({
         frameH: 0,
         hadLowBrightness: false,
         hadBlurryFrames: false,
-        hadGlare: false,
       };
       cachedBarcode.current = null;
       isCompletionCallbackInvoked.current = false;
@@ -439,7 +424,6 @@ const IdentityDocumentCamera = ({
       detectedDocumentType,
       isBrightnessLow,
       isFrameBlurry,
-      isGlareDetected,
       allElementsDetected,
       elementsOutsideScanArea,
       t
@@ -462,7 +446,6 @@ const IdentityDocumentCamera = ({
     hasGuideShown,
     isBrightnessLow,
     isFrameBlurry,
-    isGlareDetected,
     nextStep,
     status,
     detectedDocumentType,
@@ -630,33 +613,6 @@ const IdentityDocumentCamera = ({
     }
   };
 
-  // Check if face image has glare (brightness exceeds threshold). Also surfaces
-  // the result to `isGlareDetected` so the user gets an actionable hint instead
-  // of a silently-stalled scan.
-  const checkFaceGlare = async (faceImage: string): Promise<boolean> => {
-    try {
-      // Check entire face region for glare
-      const hasGlare = await OpenCVModule.isRectangularRegionBright(
-        faceImage,
-        0,
-        0,
-        100, // Full face width
-        100, // Full face height
-        MAX_BRIGHTNESS_THRESHOLD
-      );
-      // OR-accumulate into the per-frame glare signal (reset at frame top); the
-      // frame handler feeds it through the stabilized UI flag. Also record the
-      // diagnostic.
-      if (hasGlare) {
-        rawGlareRef.current = true;
-        diagStats.current.hadGlare = true;
-      }
-      return hasGlare;
-    } catch (error) {
-      return false; // Assume no glare on error
-    }
-  };
-
   // Check if face is fully visible (not cropped at edges)
   const isFaceFullyVisible = (
     face: Face,
@@ -673,35 +629,6 @@ const IdentityDocumentCamera = ({
     );
   };
 
-  // Check if document image has glare
-  const checkDocumentGlare = async (
-    image: string,
-    width: number,
-    height: number
-  ): Promise<boolean> => {
-    try {
-      // Check center 80% region for glare (document area)
-      const hasGlare = await OpenCVModule.isRectangularRegionBright(
-        image,
-        Math.round(width * 0.1),
-        Math.round(height * 0.1),
-        Math.round(width * 0.8),
-        Math.round(height * 0.8),
-        MAX_BRIGHTNESS_THRESHOLD
-      );
-      // OR-accumulate into the per-frame glare signal (reset at frame top); the
-      // frame handler feeds it through the stabilized UI flag. Also record the
-      // diagnostic.
-      if (hasGlare) {
-        rawGlareRef.current = true;
-        diagStats.current.hadGlare = true;
-      }
-      return hasGlare;
-    } catch (error) {
-      return false;
-    }
-  };
-
   const setNextStepAndVibrate = useCallback(
     (
       nextStepType:
@@ -780,12 +707,9 @@ const IdentityDocumentCamera = ({
       // carried over from the previous side).
       brightnessLowFlag.current.reset(false);
       blurryFlag.current.reset(false);
-      glareFlag.current.reset(false);
-      rawGlareRef.current = false;
       documentPresentRef.current = false;
       setIsBrightnessLow(false);
       setIsFrameBlurry(false);
-      setIsGlareDetected(false);
 
       if (nextStepType !== 'COMPLETED') {
         setTimeout(() => {
@@ -1189,14 +1113,12 @@ const IdentityDocumentCamera = ({
         const faceFullyVisible =
           primaryFaces[0] &&
           isFaceFullyVisible(primaryFaces[0], frameWidth, frameHeight);
-        const hasGlare = await checkFaceGlare(croppedFaces[0]);
 
-        if (!faceFullyVisible || hasGlare) {
-          // Reject face with glare or partially visible
+        if (!faceFullyVisible) {
+          // Reject partially visible face
           if (isDebugEnabled()) {
             debugLog('IdentityDocumentCamera', '[FACE] Rejected', {
               fullyVisible: faceFullyVisible,
-              hasGlare,
             });
           }
           // Continue scanning without locking this face
@@ -1252,8 +1174,23 @@ const IdentityDocumentCamera = ({
       // 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.
+      // `consensus.stable` also requires a "confident" vote — every contested
+      // cell's winner must lead by a margin. On a dense TD3 passport MRZ (88
+      // cells) a single stubborn OCR-B look-alike (A↔4, S↔5) can keep one cell
+      // at a 1-vote margin indefinitely, so `stable` never flips and the scan
+      // wedges on "hold steady" — even though the check-digit-VALID consensus
+      // has been UNCHANGED for many frames. Check digits are the real correctness
+      // guarantee; a long unchanged, valid streak is conclusive. So also accept
+      // once a valid consensus has held unchanged for MRZ_STREAK_ACCEPT_OVERRIDE
+      // frames (well above `stabilityTarget`), independent of the margin gate.
+      // Short streaks still require the full confident+stable gate, preserving
+      // the early-misread protection.
+      const mrzValidStreakSettled =
+        parsedMRZData?.valid === true &&
+        consensus.stableStreak >= MRZ_STREAK_ACCEPT_OVERRIDE;
       const mrzStableAndValid =
-        consensus.stable && parsedMRZData?.valid === true;
+        (consensus.stable || mrzValidStreakSettled) &&
+        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.
@@ -1337,23 +1274,6 @@ const IdentityDocumentCamera = ({
             return;
           }
 
-          // Check for glare on ID back before accepting
-          const hasGlare = await checkDocumentGlare(
-            image,
-            frameWidth,
-            frameHeight
-          );
-          if (hasGlare) {
-            if (isDebugEnabled()) {
-              debugLog(
-                'IdentityDocumentCamera',
-                '[ID_BACK] Rejected - glare detected'
-              );
-            }
-            setStatus('SCANNING');
-            return;
-          }
-
           if (isDebugEnabled()) {
             debugLog('IdentityDocumentCamera', '[ID_BACK] MRZ validated', {
               documentNumber: parsedMRZData?.fields?.documentNumber,
@@ -1530,29 +1450,17 @@ const IdentityDocumentCamera = ({
                   setIsTorchOn(true);
                 }
 
-                // Check hologram face for glare
-                const hasGlare = await checkFaceGlare(primaryFaceOnly);
-                if (!hasGlare) {
-                  faceImages.current.push(primaryFaceOnly);
-                  lastHologramCaptureTime.current = Date.now();
-                  hologramImageCountRef.current = faceImages.current.length;
+                faceImages.current.push(primaryFaceOnly);
+                lastHologramCaptureTime.current = Date.now();
+                hologramImageCountRef.current = faceImages.current.length;
 
-                  if (isDebugEnabled()) {
-                    debugLog(
-                      'IdentityDocumentCamera',
-                      '[HOLOGRAM] Frame captured',
-                      {
-                        frameIndex: faceImages.current.length - 1,
-                        totalFrames: faceImages.current.length,
-                      }
-                    );
-                  }
-                } else if (isDebugEnabled()) {
+                if (isDebugEnabled()) {
                   debugLog(
                     'IdentityDocumentCamera',
-                    '[HOLOGRAM] Rejected glare frame',
+                    '[HOLOGRAM] Frame captured',
                     {
-                      collectedCount: faceImages.current.length,
+                      frameIndex: faceImages.current.length - 1,
+                      totalFrames: faceImages.current.length,
                     }
                   );
                 }
@@ -1955,23 +1863,6 @@ const IdentityDocumentCamera = ({
             return;
           }
 
-          // Check for glare on passport before accepting
-          const hasGlare = await checkDocumentGlare(
-            image,
-            frameWidth,
-            frameHeight
-          );
-          if (hasGlare) {
-            if (isDebugEnabled()) {
-              debugLog(
-                'IdentityDocumentCamera',
-                '[PASSPORT] Rejected - glare detected'
-              );
-            }
-            continueScanning(false);
-            return;
-          }
-
           setDetectedDocumentType('PASSPORT');
           setStatus('SCANNED');
 
@@ -2005,23 +1896,6 @@ const IdentityDocumentCamera = ({
             return;
           }
 
-          // Check for glare on ID front before accepting
-          const hasGlare = await checkDocumentGlare(
-            image,
-            frameWidth,
-            frameHeight
-          );
-          if (hasGlare) {
-            if (isDebugEnabled()) {
-              debugLog(
-                'IdentityDocumentCamera',
-                '[ID_FRONT] Rejected - glare detected'
-              );
-            }
-            continueScanning(false);
-            return;
-          }
-
           setDetectedDocumentType('ID_FRONT');
           setStatus('SCANNED');
 
@@ -2136,18 +2010,6 @@ const IdentityDocumentCamera = ({
       const rawBrightnessLow = !isRegionBright;
       if (rawBrightnessLow) diagStats.current.hadLowBrightness = true;
 
-      // Per-frame glare is asserted by the accept-time helpers (checkDocumentGlare
-      // /checkFaceGlare), but those run inside handleFaceAndText which is fired
-      // (async, un-awaited) LATER in this handler — so this frame's glare result
-      // isn't known yet at the stabilization block below. We therefore feed the
-      // stabilizer the PREVIOUS frame's glare signal (captured here before the
-      // reset). At ~8fps the one-frame lag is imperceptible and the hysteresis
-      // smooths it anyway; without this the read would always see false and the
-      // glare warning could never fire. Reset after capturing so a now-clean
-      // view clears (no latch).
-      const prevFrameGlare = rawGlareRef.current;
-      rawGlareRef.current = false;
-
       // Check blur only in center region (area of interest) to avoid false positives
       // from iOS depth-of-field background blur
       let isNotBlurry = true;
@@ -2197,8 +2059,8 @@ const IdentityDocumentCamera = ({
       // MUST run BEFORE the quality-gate early-return below: a dark or blurry
       // frame is exactly what makes hasAcceptableQuality false, so if this ran
       // after the gate the "too dark" / "hold steady" warnings could never
-      // raise (their triggering frames would have already returned). Blur/glare
-      // are gated on document presence; brightness shows regardless, since a
+      // raise (their triggering frames would have already returned). Blur
+      // is gated on document presence; brightness shows regardless, since a
       // dark room is worth flagging before the card is even framed.
       //
       // Presence combines the previous frame's confirmed value (documentPresent-
@@ -2207,7 +2069,7 @@ const IdentityDocumentCamera = ({
       // processing). Without the raw proxy, a document that is blurry/dark from
       // its very first framed moment would keep failing the quality gate and
       // early-returning before documentPresentRef is ever set true — suppressing
-      // its blur/glare hints for ~30 frames. The proxy lets the hint fire on the
+      // its blur hints for ~30 frames. The proxy lets the hint fire on the
       // first framed frame.
       const rawDocumentPresent =
         (frame.faces?.length ?? 0) > 0 ||
@@ -2217,9 +2079,6 @@ const IdentityDocumentCamera = ({
         documentPresentRef.current || rawDocumentPresent;
       setIsBrightnessLow(brightnessLowFlag.current.push(rawBrightnessLow));
       setIsFrameBlurry(blurryFlag.current.push(documentWasPresent && isBlurry));
-      setIsGlareDetected(
-        glareFlag.current.push(documentWasPresent && prevFrameGlare)
-      );
       // -------------------------------------------------------------------
 
       // Store quality metrics in ref for access in handleFaceAndText callback
@@ -2284,6 +2143,32 @@ const IdentityDocumentCamera = ({
           })),
         };
 
+        // Isolate the MRZ text (bottom-of-document blocks matching the MRZ
+        // pattern) and feed ONLY that to the multi-frame consensus. CRITICAL:
+        // this must run for EVERY build, not just debug — the identical logic
+        // used to live only inside an `if (isDebugEnabled())` overlay block, so
+        // in release `mrzOnlyText` was never set and the aggregator fell back to
+        // the FULL OCR text (including the passport header "PASSPORT / TÜR /
+        // REPUBLIC OF…"). That header noise kept the per-character consensus from
+        // ever stabilizing, so a passport wedged on "hold steady" forever in
+        // release while working in debug/example. Passport MRZ sits low on the
+        // page; the `y > bottom-half` filter drops the header/photo-area text.
+        if (textBlocks.length > 0) {
+          const bottomHalf = frame.height * 0.5;
+          const mrzBlocks = textBlocks.filter(
+            (block) =>
+              block.blockFrame &&
+              block.blockFrame.y > bottomHalf &&
+              MRZ_BLOCK_PATTERN.test(block.text)
+          );
+          if (mrzBlocks.length > 0) {
+            scannedText.mrzOnlyText = [...mrzBlocks]
+              .sort((a, b) => (a.blockFrame?.y || 0) - (b.blockFrame?.y || 0))
+              .map((b) => b.text)
+              .join('\n');
+          }
+        }
+
         // Read barcodes directly from native ML Kit results
         let barcodes: Barcode[] = [];
         if (frame.barcodes) {
@@ -2800,18 +2685,6 @@ const IdentityDocumentCamera = ({
             </TextView>
           )}
 
-          {/* Hologram capture progress — 16 frames are collected while the user
-              tilts the document; show N/16 so "tilt slowly" feels responsive
-              instead of a silent wait. */}
-          {nextStep === 'SCAN_HOLOGRAM' && status !== 'SCANNED' && (
-            <TextView style={styles.hologramProgress}>
-              {t('identityDocumentCamera.hologramProgress', {
-                current: hologramImageCount,
-                total: HOLOGRAM_IMAGE_COUNT,
-              })}
-            </TextView>
-          )}
-
           <AnimatedText
             style={[
               styles.topZoneText,
@@ -2827,7 +2700,7 @@ const IdentityDocumentCamera = ({
                 opacity: errorFlashAnim,
               },
               // 3. Warning (yellow) - quality issues
-              (isBrightnessLow || isFrameBlurry || isGlareDetected) &&
+              (isBrightnessLow || isFrameBlurry) &&
                 styles.topZoneTextWarning,
               // 4. Scanning (green) - all elements detected AND inside scan area
               status === 'SCANNING' &&
@@ -2835,7 +2708,6 @@ const IdentityDocumentCamera = ({
                 elementsOutsideScanArea.length === 0 &&
                 !isBrightnessLow &&
                 !isFrameBlurry &&
-                !isGlareDetected &&
                 styles.topZoneTextScanning,
               // 5. Default (white) - aligning (not all detected OR elements outside scan area)
             ]}
@@ -2846,7 +2718,6 @@ const IdentityDocumentCamera = ({
               detectedDocumentType,
               isBrightnessLow,
               isFrameBlurry,
-              isGlareDetected,
               allElementsDetected,
               elementsOutsideScanArea,
               t
@@ -2899,7 +2770,9 @@ const IdentityDocumentCamera = ({
             />
           ) : null}
         </View>
-        {isDebugEnabled() && (
+        {/* Debug overlay is DEV-only: hard-gated on __DEV__ so a release build
+            can never render it, even if a consumer passes debug={true}. */}
+        {__DEV__ && isDebugEnabled() && (
           <DebugOverlay
             nextStep={nextStep}
             status={status}
@@ -2922,7 +2795,7 @@ const IdentityDocumentCamera = ({
             elementsOutsideScanArea={elementsOutsideScanArea}
           />
         )}
-        {testMode && testModeData && (
+        {__DEV__ && testMode && testModeData && (
           <TestModePanel mrzText={testModeData.mrzText} />
         )}
 
@@ -3070,13 +2943,6 @@ const styles = StyleSheet.create({
     fontWeight: '500',
     marginBottom: 4,
   },
-  hologramProgress: {
-    color: '#4CAF50',
-    fontSize: 14,
-    textAlign: 'center',
-    fontWeight: '600',
-    marginBottom: 4,
-  },
   topZoneText: {
     color: 'white',
     fontSize: 20,

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

@@ -172,7 +172,6 @@ export function getStatusMessage(
   detectedDocumentType: DocumentType,
   isBrightnessLow: boolean,
   isFrameBlurry: boolean,
-  isGlareDetected: boolean,
   allElementsDetected: boolean,
   elementsOutsideScanArea: string[],
   t: (key: string, params?: Record<string, unknown>) => string
@@ -204,14 +203,6 @@ export function getStatusMessage(
     return t('identityDocumentCamera.lowBrightness');
   }
 
-  // Glare is a primary failure mode (reflections off the laminate/photo). It was
-  // previously detected but never communicated, so the scan just appeared to
-  // hang. Tell the user how to fix it. Ranked above blur because a glare hotspot
-  // both blocks acceptance and often reads as a "sharp" (non-blurry) frame.
-  if (isGlareDetected) {
-    return t('identityDocumentCamera.reduceGlare');
-  }
-
   if (isFrameBlurry) {
     return t('identityDocumentCamera.avoidBlur');
   }

package/src/Translation/Resources/en.ts

@@ -238,12 +238,8 @@ export default {
   'identityDocumentCamera.frontSide': 'Front',
   'identityDocumentCamera.backSide': 'Back',
   'identityDocumentCamera.hologramCheck': 'Hologram',
-  'identityDocumentCamera.hologramProgress':
-    'Capturing hologram… {{current}}/{{total}}',
   'identityDocumentCamera.keepSteady': 'Keep device steady',
   'identityDocumentCamera.avoidBlur': 'Keep device steady',
-  'identityDocumentCamera.reduceGlare':
-    'Glare detected. Tilt the document or move away from direct light.',
   'identityDocumentCamera.wrongSideFront':
     'Show the front side of your document',
   'identityDocumentCamera.wrongSideBack': 'Show the back side of your document',

package/src/Translation/Resources/tr.ts

@@ -239,12 +239,8 @@ export default {
   'identityDocumentCamera.frontSide': 'Ön',
   'identityDocumentCamera.backSide': 'Arka',
   'identityDocumentCamera.hologramCheck': 'Hologram',
-  'identityDocumentCamera.hologramProgress':
-    'Hologram yakalanıyor… {{current}}/{{total}}',
   'identityDocumentCamera.keepSteady': 'Cihazı sabit tutun',
   'identityDocumentCamera.avoidBlur': 'Cihazı sabit tutun',
-  'identityDocumentCamera.reduceGlare':
-    'Parlama algılandı. Belgeyi hafifçe eğin veya doğrudan ışıktan uzaklaşın.',
   'identityDocumentCamera.wrongSideFront': 'Belgenizin ön yüzünü gösterin',
   'identityDocumentCamera.wrongSideBack': 'Belgenizin arka yüzünü gösterin',
   'identityDocumentCamera.idCardDetected': 'Kimlik kartı algılandı',

package/src/version.ts

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