@trustchex/react-native-sdk 1.487.0 → 1.489.0

package/lib/typescript/src/Shared/Libs/jp2Decode.d.ts

@@ -0,0 +1,13 @@
+import { Buffer } from 'buffer';
+/**
+ * Decode a JPEG2000 buffer to JPEG using the native iOS decoder.
+ *
+ * Returns the JPEG bytes + mime type on success, or null when native decode is
+ * unavailable (Android, or the module isn't linked) or fails — callers should
+ * fall back to their existing behaviour (keep raw JP2).
+ */
+export declare function decodeJp2ToJpeg(jp2Buffer: Buffer): Promise<{
+    base64: string;
+    mimeType: string;
+} | null>;
+//# sourceMappingURL=jp2Decode.d.ts.map

package/lib/typescript/src/Shared/Libs/jp2Decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jp2Decode.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/jp2Decode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAsBhC;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAetD"}

package/lib/typescript/src/Shared/Libs/mrz.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mrz.utils.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/mrz.utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AA6DpD;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;;sBAOwB,MAAM,KAAG,MAAM;2BA2oC7B,MAAM,gBACF,OAAO,KACnB,mBAAmB;0CAsKuB,MAAM,KAAG,mBAAmB;wCA9mC9B,MAAM,KAAG,MAAM,EAAE,EAAE;wCAwnCnB,MAAM,KAAG,MAAM;gCAmDvB,MAAM;;;;;+BAz1BP,MAAM,KAAG,OAAO;iCA4Bd,MAAM,KAAG,MAAM;wCA20BR,MAAM,GAAG,IAAI,KAAG,MAAM,GAAG,IAAI;kCA97ChE,MAAM,GAAG,IAAI,GAAG,SAAS,KAC9B,MAAM,GAAG,IAAI;;AA68ChB,wBAWE"}
+{"version":3,"file":"mrz.utils.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/mrz.utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AA4EpD;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;;sBAOwB,MAAM,KAAG,MAAM;2BA+oC7B,MAAM,gBACF,OAAO,KACnB,mBAAmB;0CAwKuB,MAAM,KAAG,mBAAmB;wCApnC9B,MAAM,KAAG,MAAM,EAAE,EAAE;wCA8nCnB,MAAM,KAAG,MAAM;gCAmDvB,MAAM;;;;;+BA/1BP,MAAM,KAAG,OAAO;iCA4Bd,MAAM,KAAG,MAAM;wCAi1BR,MAAM,GAAG,IAAI,KAAG,MAAM,GAAG,IAAI;kCAn9ChE,MAAM,GAAG,IAAI,GAAG,SAAS,KAC9B,MAAM,GAAG,IAAI;;AAk+ChB,wBAWE"}

package/lib/typescript/src/Shared/Libs/mrzTransliteration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mrzTransliteration.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/mrzTransliteration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAyFhE,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACvC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,EACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GACvB,YAAY,CAmCd"}
+{"version":3,"file":"mrzTransliteration.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/mrzTransliteration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAyFhE,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACvC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,EACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GACvB,YAAY,CAgDd"}

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

@@ -48,6 +48,11 @@ declare const _default: {
     'diagnosticReport.noticeBody': string;
     'diagnosticReport.continue': string;
     'diagnosticReport.cancel': string;
+    'diagnosticReport.shareFailedTitle': string;
+    'diagnosticReport.shareFailedBody': string;
+    'diagnosticReport.uploadAction': string;
+    'diagnosticReport.uploadSuccess': string;
+    'diagnosticReport.uploadFailed': string;
     'livenessDetectionScreen.guideHeader': string;
     'livenessDetectionScreen.guideText': string;
     'livenessDetectionScreen.guidePoint1': string;
@@ -70,6 +75,13 @@ declare const _default: {
     'eidScannerScreen.guideHeader': string;
     'eidScannerScreen.guideText': string;
     'eidScannerScreen.invalidMRZFields': string;
+    'eidScannerScreen.error': string;
+    'eidScannerScreen.errorCode': string;
+    'eidScannerScreen.nfcGenericError': string;
+    'eidScannerScreen.nfcReadFailed': string;
+    'eidScannerScreen.nfcAuthFailed': string;
+    'eidScannerScreen.nfcTagLost': string;
+    'eidScannerScreen.nfcTimeout': string;
     'eidScannerScreen.faceImageNotFound': string;
     'eidScannerScreen.documentCode': string;
     'eidScannerScreen.nationality': 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,wBAgQE"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAmRE"}

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

@@ -48,6 +48,11 @@ declare const _default: {
     'diagnosticReport.noticeBody': string;
     'diagnosticReport.continue': string;
     'diagnosticReport.cancel': string;
+    'diagnosticReport.shareFailedTitle': string;
+    'diagnosticReport.shareFailedBody': string;
+    'diagnosticReport.uploadAction': string;
+    'diagnosticReport.uploadSuccess': string;
+    'diagnosticReport.uploadFailed': string;
     'livenessDetectionScreen.guideHeader': string;
     'livenessDetectionScreen.guideText': string;
     'livenessDetectionScreen.guidePoint1': string;
@@ -70,6 +75,13 @@ declare const _default: {
     'eidScannerScreen.guideHeader': string;
     'eidScannerScreen.guideText': string;
     'eidScannerScreen.invalidMRZFields': string;
+    'eidScannerScreen.error': string;
+    'eidScannerScreen.errorCode': string;
+    'eidScannerScreen.nfcGenericError': string;
+    'eidScannerScreen.nfcReadFailed': string;
+    'eidScannerScreen.nfcAuthFailed': string;
+    'eidScannerScreen.nfcTagLost': string;
+    'eidScannerScreen.nfcTimeout': string;
     'eidScannerScreen.faceImageNotFound': string;
     'eidScannerScreen.documentCode': string;
     'eidScannerScreen.nationality': 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,wBAmQE"}
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAsRE"}

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustchex/react-native-sdk",
-  "version": "1.487.0",
+  "version": "1.489.0",
   "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/EIDScanner.tsx

@@ -11,6 +11,7 @@ import { eidReader } from '../EIDReader/eidReader';
 import NativeProgressBar from './NativeProgressBar';
 import type { MRZFields } from '../Types/mrzFields';
 import { buildDocumentName } from '../Libs/mrzTransliteration';
+import type { DocumentName } from '../Types/documentReadResult';
 import { normalizeFromMRZInfo } from '../Libs/documentDataNormalizer';
 import { useTranslation } from 'react-i18next';
 import AppContext from '../Contexts/AppContext';
@@ -55,13 +56,20 @@ const EIDScanner = ({
   const [documentMRZInfo, setDocumentMRZInfo] = React.useState<MRZInfo>();
   const [documentFaceImageMimeType, setDocumentFaceImageMimeType] =
     React.useState<string>();
-  const [documentName, setDocumentName] = React.useState<import('../Types/documentReadResult').DocumentName>();
+  const [documentName, setDocumentName] = React.useState<DocumentName>();
   const [progress, setProgress] = React.useState(0);
   const [progressStage, setProgressStage] = React.useState<string>('');
 
   // Animation for pulse indicator
   const pulseAnim = useRef(new Animated.Value(1)).current;
 
+  // Strip MRZ filler (`<`) and trim; returns '' for empty/filler-only input so
+  // the UI can hide fields the chip didn't actually provide.
+  const cleanField = useCallback((value?: string | null): string => {
+    if (!value) return '';
+    return value.replace(/</g, ' ').replace(/\s+/g, ' ').trim();
+  }, []);
+
   // Format date from YYMMDD to DD/MM/YYYY (matching Flutter SDK)
   const formatDate = useCallback((dateStr?: string | null) => {
     if (!dateStr) return '';
@@ -137,20 +145,30 @@ const EIDScanner = ({
   const [voiceGuidanceMessage, setVoiceGuidanceMessage] = useState<string>();
   const [attemptNumber, setAttemptNumber] = useState<number>(0);
 
-  const getFieldsFromMRZ = useCallback((mrz: MRZInfo) => {
-    return {
-      documentCode: mrzUtils.normalizeDocumentCode(mrz.getDocumentCode()),
-      personalNumber: mrz.getPersonalNumber() || mrz.getOptionalData1(),
-      documentNumber: mrz.getDocumentNumber(),
-      firstName: mrz.getSecondaryIdentifier(),
-      lastName: mrz.getPrimaryIdentifier(),
-      birthDate: mrz.getDateOfBirth(),
-      expirationDate: mrz.getDateOfExpiry(),
-      issuingState: mrz.getIssuingState(),
-      sex: mrz.getGender().getStrCode(),
-      nationality: mrz.getNationality(),
-    } satisfies MRZFields;
-  }, []);
+  const getFieldsFromMRZ = useCallback(
+    (mrz: MRZInfo, name?: DocumentName | null) => {
+      // Prefer the resolved name (DG11 printed name / transliteration) over the
+      // raw DG1 split. Some chips — notably Turkish PACE passports — return a DG1
+      // name field with no `<<` separator, so getPrimaryIdentifier() holds the
+      // FULL name and getSecondaryIdentifier() is empty ("name as surname"). The
+      // resolved name corrects that; fall back to the raw split when absent.
+      const firstName = name?.displayFirst || mrz.getSecondaryIdentifier();
+      const lastName = name?.displayLast || mrz.getPrimaryIdentifier();
+      return {
+        documentCode: mrzUtils.normalizeDocumentCode(mrz.getDocumentCode()),
+        personalNumber: mrz.getPersonalNumber() || mrz.getOptionalData1(),
+        documentNumber: mrz.getDocumentNumber(),
+        firstName,
+        lastName,
+        birthDate: mrz.getDateOfBirth(),
+        expirationDate: mrz.getDateOfExpiry(),
+        issuingState: mrz.getIssuingState(),
+        sex: mrz.getGender().getStrCode(),
+        nationality: mrz.getNationality(),
+      } satisfies MRZFields;
+    },
+    []
+  );
 
   const readNFC = useCallback(async () => {
     const startTime = Date.now();
@@ -268,7 +286,7 @@ const EIDScanner = ({
 
           if (appContext.skipNfcResultScreen && onScanSuccess) {
             onScanSuccess(
-              getFieldsFromMRZ(passportData.mrz),
+              getFieldsFromMRZ(passportData.mrz, builtName),
               passportData.faceImage,
               passportData.mimeType
             );
@@ -349,7 +367,42 @@ const EIDScanner = ({
       ).catch(() => {});
 
       console.debug('NFC scan error:', error);
-      // Ignore error - let user retry
+
+      // Surface an accurate message instead of failing silently. eidReader
+      // attaches `nfcCategory` + `nfcCode`.
+      //   - User-correctable failures (wrong doc data, card moved/too slow, NFC
+      //     off) get a specific, actionable message and NO code — there's a clear
+      //     action to take, a support code would just be noise.
+      //   - Everything else is an unexpected/system error: show a generic message
+      //     plus the reportable code (e.g. NFC-READ-6A82) so the user can quote it.
+      //   - user_cancelled stays silent (the user dismissed the native NFC sheet).
+      const tagged = error as
+        | { nfcCategory?: string; nfcCode?: string }
+        | undefined;
+      const category = tagged?.nfcCategory ?? errorType;
+
+      // category -> actionable message key for the user-mistake cases.
+      const ACTIONABLE: Record<string, string> = {
+        auth_failed: 'eidScannerScreen.nfcAuthFailed',
+        tag_lost: 'eidScannerScreen.nfcTagLost',
+        timeout: 'eidScannerScreen.nfcTimeout',
+        not_enabled: 'eidScannerScreen.nfcNotEnabled',
+      };
+
+      if (category !== 'user_cancelled') {
+        const actionableKey = ACTIONABLE[category];
+        if (actionableKey) {
+          // Clear user action available — meaningful message, no support code.
+          Alert.alert(t('eidScannerScreen.error'), t(actionableKey));
+        } else {
+          // Unexpected/system error — generic message + reportable support code.
+          const errorCode = tagged?.nfcCode ?? 'NFC-READ';
+          const message = `${t('eidScannerScreen.nfcGenericError')}\n\n${t(
+            'eidScannerScreen.errorCode'
+          )}: ${errorCode}`;
+          Alert.alert(t('eidScannerScreen.error'), message);
+        }
+      }
     } finally {
       setIsScanning(false);
       setProgress(0);
@@ -549,7 +602,11 @@ const EIDScanner = ({
                     <View style={styles.idCardPhotoFrame}>
                       {documentFaceImage &&
                       (documentFaceImageMimeType === 'image/jpeg' ||
-                        documentFaceImageMimeType === 'image/png') ? (
+                        documentFaceImageMimeType === 'image/png' ||
+                        // Android's <Image> decodes a raw JP2 data URI; on iOS
+                        // the chip JP2 is converted to JPEG before this point
+                        // (native ImageIO), so iOS never reaches here as jp2.
+                        documentFaceImageMimeType === 'image/jp2') ? (
                         <Image
                           source={{
                             uri: `data:${documentFaceImageMimeType};base64,${documentFaceImage}`,
@@ -567,59 +624,86 @@ const EIDScanner = ({
                     </View>
                   </View>
 
-                  {/* Right column: all fields as grid */}
+                  {/* Right column: all fields as grid. Each field renders only
+                      when the chip actually provided a value — filler-only /
+                      empty fields are hidden rather than shown blank. */}
                   <View style={styles.idCardFields}>
-                    <IDCardField
-                      label={t('eidScannerScreen.surname')}
-                      value={documentName?.displayLast ?? documentMRZInfo.getPrimaryIdentifier()}
-                    />
-                    <IDCardField
-                      label={t('eidScannerScreen.name')}
-                      value={documentName?.displayFirst ?? documentMRZInfo.getSecondaryIdentifier()}
-                    />
-                    <IDCardField
-                      label={t('eidScannerScreen.documentNumber')}
-                      value={documentMRZInfo.getDocumentNumber()}
-                    />
-                    <IDCardField
-                      label={t('eidScannerScreen.birthDate')}
-                      value={formatDate(documentMRZInfo.getDateOfBirth())}
-                    />
-                    <IDCardField
-                      label={t('eidScannerScreen.expirationDate')}
-                      value={formatDate(documentMRZInfo.getDateOfExpiry())}
-                    />
-                    <IDCardField
-                      label={t('eidScannerScreen.gender')}
-                      value={formatGender(
+                    {(() => {
+                      const surname =
+                        documentName?.displayLast ??
+                        cleanField(documentMRZInfo.getPrimaryIdentifier());
+                      const givenNames =
+                        documentName?.displayFirst ??
+                        cleanField(documentMRZInfo.getSecondaryIdentifier());
+                      const docNumber = cleanField(
+                        documentMRZInfo.getDocumentNumber()
+                      );
+                      const birthDate = formatDate(
+                        documentMRZInfo.getDateOfBirth()
+                      );
+                      const expiry = formatDate(
+                        documentMRZInfo.getDateOfExpiry()
+                      );
+                      const gender = formatGender(
                         documentMRZInfo.getGender().getStrCode()
-                      )}
-                    />
-                    <IDCardField
-                      label={t('eidScannerScreen.nationality')}
-                      value={formatNationality(
+                      );
+                      const nationality = formatNationality(
                         documentMRZInfo.getNationality()
-                      )}
-                    />
-                    <IDCardField
-                      label={t('eidScannerScreen.issuingState')}
-                      value={formatNationality(
+                      );
+                      const issuingState = formatNationality(
                         documentMRZInfo.getIssuingState()
-                      )}
-                    />
-                    {!!(
-                      documentMRZInfo.getPersonalNumber() ||
-                      documentMRZInfo.getOptionalData1()
-                    ) && (
-                      <IDCardField
-                        label={t('eidScannerScreen.personalNumber')}
-                        value={
-                          documentMRZInfo.getPersonalNumber() ||
-                          documentMRZInfo.getOptionalData1() ||
-                          ''
-                        }
-                      />
-                    )}
+                      );
+                      const personalNumber = cleanField(
+                        documentMRZInfo.getPersonalNumber() ||
+                          documentMRZInfo.getOptionalData1()
+                      );
+
+                      const fields: Array<{ label: string; value: string }> = [
+                        {
+                          label: t('eidScannerScreen.surname'),
+                          value: surname,
+                        },
+                        {
+                          label: t('eidScannerScreen.name'),
+                          value: givenNames,
+                        },
+                        {
+                          label: t('eidScannerScreen.documentNumber'),
+                          value: docNumber,
+                        },
+                        {
+                          label: t('eidScannerScreen.birthDate'),
+                          value: birthDate,
+                        },
+                        {
+                          label: t('eidScannerScreen.expirationDate'),
+                          value: expiry,
+                        },
+                        { label: t('eidScannerScreen.gender'), value: gender },
+                        {
+                          label: t('eidScannerScreen.nationality'),
+                          value: nationality,
+                        },
+                        {
+                          label: t('eidScannerScreen.issuingState'),
+                          value: issuingState,
+                        },
+                        {
+                          label: t('eidScannerScreen.personalNumber'),
+                          value: personalNumber,
+                        },
+                      ];
+
+                      return fields
+                        .filter((f) => f.value && f.value.trim().length > 0)
+                        .map((f) => (
+                          <IDCardField
+                            key={f.label}
+                            label={f.label}
+                            value={f.value}
+                          />
+                        ));
+                    })()}
                   </View>
                 </View>
               </View>
@@ -637,7 +721,7 @@ const EIDScanner = ({
                         documentFaceImageMimeType
                       ) {
                         onScanSuccess(
-                          getFieldsFromMRZ(documentMRZInfo),
+                          getFieldsFromMRZ(documentMRZInfo, documentName),
                           documentFaceImage,
                           documentFaceImageMimeType
                         );
@@ -724,7 +808,7 @@ const EIDScanner = ({
                     documentFaceImageMimeType
                   ) {
                     onScanSuccess(
-                      getFieldsFromMRZ(documentMRZInfo),
+                      getFieldsFromMRZ(documentMRZInfo, documentName),
                       documentFaceImage,
                       documentFaceImageMimeType
                     );

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

@@ -17,7 +17,15 @@ export const REQUIRED_CONSISTENT_DOCTYPE_DETECTIONS = 3;
 export const SIGNATURE_REGEX = /s[gi]g?n[au]?t[u]?r|imz[a]s?/i;
 export const SIGNATURE_TEXT_REGEX = /signature|imza|İmza/i;
 export const MRZ_BLOCK_PATTERN = /[A-Z0-9<]{8,}.*</i;
-export const PASSPORT_MRZ_PATTERN = /P<[A-Z]{3}/;
+// Matches the line-1 start of ANY ICAO TD3 passport MRZ, so the camera routes
+// every passport variant into the passport flow (not the ID-card back-side
+// flow). Per ICAO 9303 Part 4: `P` + a type char (filler `<` or a subtype
+// letter — `P<`, `PP` German, `PD`/`PS`/`PO` diplomatic/service/official) +
+// the issuing state (3 letters, OR the German 1-letter `D` padded with filler,
+// e.g. `P<D<<` / `PPD<<`). Previously only `P<[A-Z]{3}` matched, so German `PP`
+// and 1-letter-issuer passports fell through to the ID-card flow and were
+// wrongly asked for a back side.
+export const PASSPORT_MRZ_PATTERN = /P[A-Z<](?:[A-Z]{3}|[A-Z]<<)[A-Z<]*<</;
 
 // BDDK Madde 7 - Security Feature Validation
 // When NFC chip reading unavailable, must verify at least 4 visual security features

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

@@ -325,13 +325,24 @@ export function handleIDBackFlow(
  *
  * PASSPORT: → COMPLETED (no back side)
  * ID CARD: → SCAN_ID_BACK
+ *
+ * Routing is PASSPORT-BIASED on purpose: a passport has no back side, so if we
+ * route it to SCAN_ID_BACK it deadlocks forever waiting for a back that will
+ * never appear. We therefore only go to SCAN_ID_BACK when there is POSITIVE
+ * evidence the document is an ID card (a parsed MRZ document code that is
+ * present and not 'P'). When the type is ambiguous — e.g. the passport MRZ was
+ * never read as 'P' so the front step locked `detectedDocumentType` as
+ * 'ID_FRONT' (the torch/tilt during hologram capture makes the MRZ unreadable),
+ * or no MRZ code survived at all — we COMPLETE rather than wait for a
+ * non-existent back side. A two-sided ID card always yields an 'I'/'A'/'C'
+ * (non-'P') MRZ code, so genuine ID cards still route to SCAN_ID_BACK.
  */
 export function getNextStepAfterHologram(
   detectedDocumentType: 'ID_FRONT' | 'ID_BACK' | 'PASSPORT' | 'UNKNOWN',
   currentFrameDocType: 'ID_FRONT' | 'ID_BACK' | 'PASSPORT' | 'UNKNOWN',
   mrzDocCode: string | undefined
 ): 'COMPLETED' | 'SCAN_ID_BACK' {
-  // Check multiple sources to determine if it's a passport
+  // Any positive passport signal → done (no back side).
   const isPassport =
     detectedDocumentType === 'PASSPORT' ||
     currentFrameDocType === 'PASSPORT' ||
@@ -341,5 +352,14 @@ export function getNextStepAfterHologram(
     return 'COMPLETED';
   }
 
-  return 'SCAN_ID_BACK';
+  // Only continue to the back side when we have POSITIVE proof it's an ID card:
+  // a real MRZ document code that is present and not a passport. Without that
+  // proof, default to COMPLETED so a misclassified passport can't hang waiting
+  // for a back side that doesn't exist.
+  const hasIdCardMrzCode = !!mrzDocCode && mrzDocCode !== 'P';
+  if (hasIdCardMrzCode) {
+    return 'SCAN_ID_BACK';
+  }
+
+  return 'COMPLETED';
 }

package/src/Shared/Components/IdentityDocumentCamera.tsx

@@ -2624,8 +2624,7 @@ const IdentityDocumentCamera = ({
               isFrameBlurry,
               allElementsDetected,
               elementsOutsideScanArea,
-              t,
-              mrzReliable
+              t
             )}
           </AnimatedText>
         </View>

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

@@ -96,19 +96,17 @@ export function getStatusMessage(
   isFrameBlurry: boolean,
   allElementsDetected: boolean,
   elementsOutsideScanArea: string[],
-  t: (key: string, params?: Record<string, unknown>) => string,
-  mrzReliable: boolean = false
+  t: (key: string, params?: Record<string, unknown>) => string
 ): 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');
-  }
+  // NOTE: the "MRZ detected — hold steady" message was intentionally removed
+  // (along with its former `mrzReliable` parameter). User-facing guidance
+  // should only describe the SCAN STEP (front side, back side, hologram, etc.),
+  // not low-level MRZ-detection state. We fall through to the step-specific
+  // messages below.
 
   if (status === 'INCORRECT') {
     if (nextStep === 'SCAN_ID_FRONT_OR_PASSPORT') {

package/src/Shared/EIDReader/cardFileInputStream.ts

@@ -4,6 +4,10 @@ import type { FileSystemStructured } from './smartcards/fileSystemStructured';
 import { Buffer } from 'buffer';
 
 export class CardFileInputStream extends InputStream {
+  /** Max re-issues of a single block read before failing — mitigates transient
+   *  iOS NFC transceive drops during large-file reads (e.g. DG2). */
+  private static readonly MAX_BLOCK_READ_RETRIES = 5;
+
   private path!: FileInfo[];
   private buffer!: Buffer;
   private bufferLength!: number;
@@ -69,12 +73,32 @@ export class CardFileInputStream extends InputStream {
           newOffsetBufferInFile = this.offsetBufferInFile + this.bufferLength;
           let newOffsetInBuffer = 0;
           let newBufferLength = 0;
-          while (newBufferLength === 0) {
-            newBufferLength = await this.fillBufferFromFile(
-              this.path,
-              newOffsetBufferInFile,
-              le
-            );
+          // Retry a failed block read. The iOS NFC stack (react-native-nfc-manager)
+          // throws transient "READ BINARY" transceive errors during the many
+          // block reads of a large file like DG2 (face image); a single drop
+          // previously aborted the whole read with "Could not read file". Re-issue
+          // the SAME block (offset unchanged) a few times before giving up — this
+          // is idempotent (no secure-messaging state advances on a failed read).
+          let attempt = 0;
+          for (;;) {
+            try {
+              newBufferLength = 0;
+              while (newBufferLength === 0) {
+                newBufferLength = await this.fillBufferFromFile(
+                  this.path,
+                  newOffsetBufferInFile,
+                  le
+                );
+              }
+              break;
+            } catch (blockError) {
+              if (++attempt >= CardFileInputStream.MAX_BLOCK_READ_RETRIES) {
+                throw blockError;
+              }
+              // Brief backoff: an immediate re-issue after a transient NFC drop
+              // usually fails again; a short pause lets the RF field re-stabilise.
+              await new Promise((r) => setTimeout(r, 80 * attempt));
+            }
           }
 
           this.offsetBufferInFile = newOffsetBufferInFile;