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

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

package/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/Dynamic/LivenessDetectionScreen.js

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

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

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

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

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

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