@trustchex/react-native-sdk 1.489.0 → 1.490.1

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

@@ -762,6 +762,7 @@ const ResultScreen = () => {
             },
             children: t('resultScreen.demoStartOver')
           }), /*#__PURE__*/_jsx(DiagnosticReportButton, {
+            baseUrl: appContext.baseUrl,
             sessionId: appContext.identificationInfo?.sessionId,
             scan: {
               documentType: appContext.identificationInfo?.scannedDocument?.documentType,

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

@@ -4,36 +4,34 @@ import React, { useState } from 'react';
 import { Alert } from 'react-native';
 import { useTranslation } from 'react-i18next';
 import StyledButton from "./StyledButton.js";
-import { sendDiagnosticReport, isDiagnosticSharingAvailable } from "../Libs/sendDiagnosticReport.js";
+import { sendDiagnosticReport } from "../Libs/sendDiagnosticReport.js";
 import { SDK_VERSION } from "../../version.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * "Report a scanning issue" button for the result screen.
  *
- * Shows a brief notice describing what will be shared (the draft itself is the
- * user's review/consent step), then opens the OS share sheet — the user picks
- * email / WhatsApp / Drive / etc. and sends the diagnostic bundle to support.
- * Self-contained so the result screen only needs to render it with the scan
- * data + captured images.
+ * Shows a brief notice describing what will be shared (acting as the user's
+ * consent step), then uploads the diagnostic bundle (technical signals +
+ * scanned data + captured images) to the backend, encrypted in transit and at
+ * rest. Operators view and download the reports from the dashboard.
+ *
+ * Hidden when there's no session/baseUrl to upload to (e.g. before init).
  */
 const DiagnosticReportButton = ({
-  scan,
+  baseUrl,
   sessionId,
+  scan,
   images
 }) => {
   const {
     t
   } = useTranslation();
   const [sending, setSending] = useState(false);
-
-  // `react-native-share` is optional — hide the button entirely when the host
-  // app hasn't installed it, so apps that don't want diagnostics see no UI.
-  if (!isDiagnosticSharingAvailable()) {
+  if (!baseUrl || !sessionId) {
     return null;
   }
   const onPress = () => {
     if (sending) return;
-    // Brief notice — the share draft is the actual review/consent step.
     Alert.alert(t('diagnosticReport.noticeTitle'), t('diagnosticReport.noticeBody'), [{
       text: t('diagnosticReport.cancel'),
       style: 'cancel'
@@ -42,12 +40,16 @@ const DiagnosticReportButton = ({
       onPress: async () => {
         setSending(true);
         try {
-          await sendDiagnosticReport({
+          const {
+            uploaded
+          } = await sendDiagnosticReport({
+            baseUrl,
+            sessionId,
             scan,
             sdkVersion: SDK_VERSION,
-            sessionId,
             images
           });
+          Alert.alert(uploaded ? t('diagnosticReport.sentTitle') : t('diagnosticReport.failedTitle'), uploaded ? t('diagnosticReport.sentBody') : t('diagnosticReport.failedBody'));
         } finally {
           setSending(false);
         }

package/lib/module/Shared/Libs/diagnosticAuth.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import { Buffer } from 'buffer';
+import { hmac } from '@noble/hashes/hmac';
+import { sha256 } from '@noble/hashes/sha2';
+
+/**
+ * Authenticity signing for the demo-diagnostics upload.
+ *
+ * Demo reports have no session/account to authenticate against, so the SDK signs
+ * each upload with HMAC-SHA256 over `timestamp.nonce.rawBody` using a shared
+ * secret. The backend recomputes and rejects mismatches and stale timestamps
+ * (replay). The secret ships in the SDK, so it's an obfuscation barrier (paired
+ * with server rate limiting), not a true secret — rotate via the env var on both
+ * sides. MUST stay byte-for-byte in sync with web-app/src/lib/diagnostic-hmac.ts.
+ */
+const SECRET = process.env.TRUSTCHEX_DIAGNOSTICS_SECRET ?? 'tcx-diag-v1-2f9c4a7e8b1d4f63a05e9c7b3d61f8a2';
+const randomNonce = () => {
+  // 16 random bytes as hex. crypto.getRandomValues is polyfilled by
+  // react-native-get-random-values (already imported in crypto.utils).
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  return Buffer.from(bytes).toString('hex');
+};
+
+/** Sign a raw JSON body for the demo-diagnostics endpoint. */
+export const signDiagnosticBody = rawBody => {
+  const timestamp = Date.now().toString();
+  const nonce = randomNonce();
+  const mac = hmac(sha256, Buffer.from(SECRET, 'utf-8'), Buffer.from(`${timestamp}.${nonce}.${rawBody}`, 'utf-8'));
+  return {
+    timestamp,
+    nonce,
+    signature: Buffer.from(mac).toString('hex')
+  };
+};

package/lib/module/Shared/Libs/sendDiagnosticReport.js

@@ -1,130 +1,110 @@
 "use strict";
 
 /**
- * Assembles and shares the support diagnostic report.
+ * Assembles and uploads the support diagnostic report to the backend.
  *
- * `react-native-share` is an OPTIONAL dependency: the host app opts into the
- * diagnostic feature by installing it. When it's present we open the OS share
- * sheet with the full report (the user picks email / WhatsApp / Drive / etc. and
- * reviews before sending); when it's absent the feature is silently unavailable
- * — `isDiagnosticSharingAvailable()` returns false and the result-screen button
- * renders nothing, so apps that don't want it incur no dependency.
+ * This runs from the SDK's DEMO flow only, which is simulated client-side and
+ * has no real verification session or account — so there's no session key to
+ * encrypt with and nothing to authenticate against. The report is POSTed
+ * unauthenticated to the global demo-diagnostics endpoint over HTTPS (encrypted
+ * in transit); the backend encrypts the PII fields at rest. Internal developers
+ * view and download the reports from a hidden dashboard page.
  *
- * Attached files (staged to a temp dir via react-native-fs, already an SDK dep):
- *  - `diagnostics.json` — technical signals (device, camera, MRZ, NFC steps),
- *  - `scan-data.json`   — the scanned identity data (PII; user reviews it),
- *  - the captured document/face images.
- *
- * The readable summary rides as the share `message` so it's visible in the
- * draft regardless of the chosen app.
+ * Uploaded payload (one JSON body):
+ *  - non-PII technical metadata (platform, sdkVersion, documentType,
+ *    nfcErrorCode, paceFallbackReason, succeeded) for the list/filter,
+ *  - `diagnosticsJson` — technical signals (device, camera, MRZ, NFC steps),
+ *  - `scanDataJson`   — the scanned identity data (PII),
+ *  - `images`         — the captured document/face images (base64, PII).
  */
-import RNFS from 'react-native-fs';
+import 'react-native-get-random-values';
 import { diagnostics } from "./diagnostics.js";
 import { gatherDeviceDetails } from "./native-device-info.utils.js";
 import { buildDiagnosticReport } from "./diagnosticReport.js";
+import { signDiagnosticBody } from "./diagnosticAuth.js";
 import { logError } from "./debug.utils.js";
-
-// `react-native-share` is OPTIONAL. Load it softly so the SDK bundles and runs
-// without it; only host apps that installed it get the diagnostic feature. A
-// static `import` would make Metro fail to resolve the module when it's absent,
-// so we use a guarded require and keep the reference typed loosely.
-
-let shareModule;
-const loadShare = () => {
-  if (shareModule !== undefined) return shareModule;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const mod = require('react-native-share');
-    shareModule = mod?.default ?? mod;
-  } catch {
-    shareModule = null; // not installed — feature unavailable
-  }
-  return shareModule;
-};
+const mimeToType = mime => mime === 'png' ? 'image/png' : 'image/jpeg';
 
 /**
- * Whether diagnostic sharing is available (i.e. `react-native-share` is
- * installed in the host app). The result-screen button hides itself when false.
- */
-export const isDiagnosticSharingAvailable = () => loadShare() != null;
-const writeTemp = async (dir, name, data, encoding) => {
-  const path = `${dir}/${name}`;
-  await RNFS.writeFile(path, data, encoding);
-  return path.startsWith('file://') ? path : `file://${path}`;
-};
-/**
- * Build the report, stage attachments, and present the share sheet. Returns
- * { shared } — false on error, with `dismissed` set when the user cancelled.
+ * Build the report and upload it (over HTTPS) to the demo-diagnostics endpoint.
+ * Returns { uploaded } — false on any error (best-effort; a failed report must
+ * never disrupt the user's flow).
  */
 export const sendDiagnosticReport = async params => {
-  const share = loadShare();
-  if (!share) {
-    // Optional dependency not installed — nothing to do.
-    return {
-      shared: false
-    };
-  }
   const {
+    baseUrl,
+    sessionId,
     scan,
     sdkVersion,
-    sessionId,
     images = []
   } = params;
+  if (!baseUrl) {
+    return {
+      uploaded: false
+    };
+  }
   const now = Date.now();
   const iso = new Date(now).toISOString();
-  const device = await gatherDeviceDetails();
-  const report = buildDiagnosticReport({
-    diag: diagnostics.snapshot(now, iso),
-    device,
-    scan,
-    sdkVersion,
-    sessionId
-  });
-  const dir = `${RNFS.TemporaryDirectoryPath}/trustchex-diagnostics-${now}`;
   try {
-    await RNFS.mkdir(dir);
-    const urls = [];
-    urls.push(await writeTemp(dir, 'diagnostics.json', report.diagnosticsJson, 'utf8'));
-    urls.push(await writeTemp(dir, 'scan-data.json', report.scanDataJson, 'utf8'));
-    for (const img of images) {
-      if (!img.base64) continue;
-      urls.push(await writeTemp(dir, `${img.name}.${img.mime}`, img.base64, 'base64'));
-    }
-    try {
-      await share.open({
-        title: report.subject,
-        subject: report.subject,
-        // used by email targets
-        message: report.body,
-        urls,
-        // Per-file MIME types so targets render attachments correctly.
-        filenames: urls.map(u => u.split('/').pop() ?? 'attachment'),
-        failOnCancel: false
-      });
-      return {
-        shared: true
-      };
-    } catch (shareErr) {
-      // react-native-share throws on user cancel unless failOnCancel:false; treat
-      // a cancel as a non-error dismissal.
-      const msg = shareErr instanceof Error ? shareErr.message : String(shareErr);
-      if (/cancel|dismiss|user did not share/i.test(msg)) {
-        return {
-          shared: false,
-          dismissed: true
-        };
-      }
-      throw shareErr;
-    }
+    const device = await gatherDeviceDetails();
+    const snapshot = diagnostics.snapshot(now, iso);
+    const report = buildDiagnosticReport({
+      diag: snapshot,
+      device,
+      scan,
+      sdkVersion,
+      sessionId
+    });
+
+    // Queryable, non-PII technical metadata for the dashboard list/filter.
+    const nfc = snapshot.nfc;
+    const failingSw = nfc.failureStep ? nfc.steps.find(s => s.step === nfc.failureStep && !s.ok)?.sw : undefined;
+    const nfcErrorCode = nfc.attempted && !nfc.succeeded ? `NFC-${(nfc.errorCategory ?? 'reading_error').toUpperCase()}${failingSw ? `-${failingSw}` : ''}` : null;
+    const payload = {
+      // metadata (stored in plaintext, no PII)
+      platform: device.platform,
+      osVersion: device.systemVersion,
+      sdkVersion,
+      documentType: scan.documentType ?? snapshot.documentType ?? null,
+      dataSource: scan.dataSource ?? snapshot.dataSource ?? null,
+      nfcErrorCode,
+      paceFallbackReason: nfc.paceFallbackReason ?? null,
+      succeeded: nfc.attempted ? nfc.succeeded : null,
+      // full report (PII, encrypted at rest by the backend)
+      diagnosticsJson: report.diagnosticsJson,
+      scanDataJson: report.scanDataJson,
+      images: images.filter(img => img.base64).map(img => ({
+        name: img.name,
+        base64: img.base64,
+        mimeType: mimeToType(img.mime)
+      }))
+    };
+
+    // Sign the EXACT body bytes so the backend can verify authenticity. Use
+    // fetch directly (httpClient doesn't expose custom headers / raw body).
+    const rawBody = JSON.stringify(payload);
+    const {
+      timestamp,
+      nonce,
+      signature
+    } = signDiagnosticBody(rawBody);
+    const response = await fetch(`${baseUrl}/api/app/mobile/diagnostics`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Trustchex-Timestamp': timestamp,
+        'X-Trustchex-Nonce': nonce,
+        'X-Trustchex-Signature': signature
+      },
+      body: rawBody
+    });
+    return {
+      uploaded: response.ok
+    };
   } catch (e) {
-    logError('Diagnostics', 'Failed to share diagnostic report', e instanceof Error ? e.message : String(e));
+    logError('Diagnostics', 'Failed to upload diagnostic report', e instanceof Error ? e.message : String(e));
     return {
-      shared: false
+      uploaded: false
     };
-  } finally {
-    // Best-effort cleanup — temp files are short-lived.
-    setTimeout(() => {
-      RNFS.unlink(dir).catch(() => {});
-    }, 60_000);
   }
 };

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

@@ -46,15 +46,14 @@ export default {
   'resultScreen.demoVerbalConsentText': 'Text',
   'resultScreen.demoStartOver': 'Start Over',
   'diagnosticReport.button': 'Report a scanning issue',
-  'diagnosticReport.noticeTitle': 'Share diagnostic report',
-  'diagnosticReport.noticeBody': 'This opens a draft with your scan data, document images and technical details so support can help resolve a scanning issue. Review it before sending.',
+  'diagnosticReport.noticeTitle': 'Report a scanning issue',
+  'diagnosticReport.noticeBody': 'This sends your scan data, document images and technical details to support so they can help resolve a scanning issue.',
   'diagnosticReport.continue': 'Continue',
   'diagnosticReport.cancel': 'Cancel',
-  'diagnosticReport.shareFailedTitle': "Couldn't open the share sheet",
-  'diagnosticReport.shareFailedBody': "We couldn't attach the report to share. Send it securely to support instead?",
-  'diagnosticReport.uploadAction': 'Send to support',
-  'diagnosticReport.uploadSuccess': 'Diagnostic report sent to support.',
-  'diagnosticReport.uploadFailed': "Couldn't send the report. Please try again later.",
+  'diagnosticReport.sentTitle': 'Report sent',
+  'diagnosticReport.sentBody': 'Your diagnostic report was sent to support. Thank you.',
+  'diagnosticReport.failedTitle': "Couldn't send the report",
+  'diagnosticReport.failedBody': 'Please try again later.',
   'livenessDetectionScreen.guideHeader': 'Face Verification',
   'livenessDetectionScreen.guideText': 'Please ensure the following for best results:',
   'livenessDetectionScreen.guidePoint1': 'Remove glasses, hats, or face coverings',

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

@@ -46,15 +46,14 @@ export default {
   'resultScreen.demoVerbalConsentText': 'Metin',
   'resultScreen.demoStartOver': 'Baştan Başla',
   'diagnosticReport.button': 'Tarama sorununu bildir',
-  'diagnosticReport.noticeTitle': 'Tanılama raporu paylaş',
-  'diagnosticReport.noticeBody': 'Bu işlem; tarama verilerinizi, belge görüntülerinizi ve teknik ayrıntıları içeren bir taslak açar; böylece destek ekibi tarama sorununu çözebilir. Göndermeden önce gözden geçirin.',
+  'diagnosticReport.noticeTitle': 'Tarama sorununu bildir',
+  'diagnosticReport.noticeBody': 'Bu işlem; tarama verilerinizi, belge görüntülerinizi ve teknik ayrıntıları destek ekibine gönderir; böylece tarama sorununu çözebilirler.',
   'diagnosticReport.continue': 'Devam et',
   'diagnosticReport.cancel': 'İptal',
-  'diagnosticReport.shareFailedTitle': 'Paylaşım ekranı açılamadı',
-  'diagnosticReport.shareFailedBody': 'Raporu paylaşmak için ekleyemedik. Bunun yerine destek ekibine güvenli şekilde gönderelim mi?',
-  'diagnosticReport.uploadAction': 'Desteğe gönder',
-  'diagnosticReport.uploadSuccess': 'Tanılama raporu destek ekibine gönderildi.',
-  'diagnosticReport.uploadFailed': 'Rapor gönderilemedi. Lütfen daha sonra tekrar deneyin.',
+  'diagnosticReport.sentTitle': 'Rapor gönderildi',
+  'diagnosticReport.sentBody': 'Tanılama raporunuz destek ekibine gönderildi. Teşekkürler.',
+  'diagnosticReport.failedTitle': 'Rapor gönderilemedi',
+  'diagnosticReport.failedBody': 'Lütfen daha sonra tekrar deneyin.',
   'livenessDetectionScreen.guideHeader': 'Yüz Doğrulaması',
   'livenessDetectionScreen.guideText': 'En iyi sonuç için lütfen şunları sağlayın:',
   'livenessDetectionScreen.guidePoint1': 'Gözlük, şapka veya yüz aksesuarlarını çıkarın',

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.489.0';
+export const SDK_VERSION = '1.490.1';

package/lib/typescript/src/Screens/Static/ResultScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ResultScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Static/ResultScreen.tsx"],"names":[],"mappings":"AA8EA,QAAA,MAAM,YAAY,+CAyhCjB,CAAC;AA+IF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"ResultScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Static/ResultScreen.tsx"],"names":[],"mappings":"AA8EA,QAAA,MAAM,YAAY,+CA0hCjB,CAAC;AA+IF,eAAe,YAAY,CAAC"}

package/lib/typescript/src/Shared/Components/DiagnosticReportButton.d.ts

@@ -2,18 +2,21 @@ import React from 'react';
 import { type DiagnosticImage } from '../Libs/sendDiagnosticReport';
 import type { ScanDataForReport } from '../Libs/diagnosticReport';
 export interface DiagnosticReportButtonProps {
-    scan: ScanDataForReport;
+    /** Backend base URL the SDK was initialised with. */
+    baseUrl: string;
     sessionId?: string;
+    scan: ScanDataForReport;
     images?: DiagnosticImage[];
 }
 /**
  * "Report a scanning issue" button for the result screen.
  *
- * Shows a brief notice describing what will be shared (the draft itself is the
- * user's review/consent step), then opens the OS share sheet — the user picks
- * email / WhatsApp / Drive / etc. and sends the diagnostic bundle to support.
- * Self-contained so the result screen only needs to render it with the scan
- * data + captured images.
+ * Shows a brief notice describing what will be shared (acting as the user's
+ * consent step), then uploads the diagnostic bundle (technical signals +
+ * scanned data + captured images) to the backend, encrypted in transit and at
+ * rest. Operators view and download the reports from the dashboard.
+ *
+ * Hidden when there's no session/baseUrl to upload to (e.g. before init).
  */
 declare const DiagnosticReportButton: React.FC<DiagnosticReportButtonProps>;
 export default DiagnosticReportButton;

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

@@ -1 +1 @@
-{"version":3,"file":"DiagnosticReportButton.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/DiagnosticReportButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAIxC,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,iBAAiB,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC,2BAA2B,CA+CjE,CAAC;AAEF,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"DiagnosticReportButton.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Components/DiagnosticReportButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAIxC,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,MAAM,WAAW,2BAA2B;IAC1C,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,iBAAiB,CAAC;IACxB,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,QAAA,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC,2BAA2B,CAsDjE,CAAC;AAEF,eAAe,sBAAsB,CAAC"}

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

@@ -0,0 +1,8 @@
+export interface DiagnosticSignature {
+    timestamp: string;
+    nonce: string;
+    signature: string;
+}
+/** Sign a raw JSON body for the demo-diagnostics endpoint. */
+export declare const signDiagnosticBody: (rawBody: string) => DiagnosticSignature;
+//# sourceMappingURL=diagnosticAuth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diagnosticAuth.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/diagnosticAuth.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB;AAUD,8DAA8D;AAC9D,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,KAAG,mBAapD,CAAC"}

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

@@ -1,9 +1,22 @@
-import { type ScanDataForReport } from './diagnosticReport';
 /**
- * Whether diagnostic sharing is available (i.e. `react-native-share` is
- * installed in the host app). The result-screen button hides itself when false.
+ * Assembles and uploads the support diagnostic report to the backend.
+ *
+ * This runs from the SDK's DEMO flow only, which is simulated client-side and
+ * has no real verification session or account — so there's no session key to
+ * encrypt with and nothing to authenticate against. The report is POSTed
+ * unauthenticated to the global demo-diagnostics endpoint over HTTPS (encrypted
+ * in transit); the backend encrypts the PII fields at rest. Internal developers
+ * view and download the reports from a hidden dashboard page.
+ *
+ * Uploaded payload (one JSON body):
+ *  - non-PII technical metadata (platform, sdkVersion, documentType,
+ *    nfcErrorCode, paceFallbackReason, succeeded) for the list/filter,
+ *  - `diagnosticsJson` — technical signals (device, camera, MRZ, NFC steps),
+ *  - `scanDataJson`   — the scanned identity data (PII),
+ *  - `images`         — the captured document/face images (base64, PII).
  */
-export declare const isDiagnosticSharingAvailable: () => boolean;
+import 'react-native-get-random-values';
+import { type ScanDataForReport } from './diagnosticReport';
 export interface DiagnosticImage {
     /** Stable file name without extension, e.g. "mrz-side". */
     name: string;
@@ -11,20 +24,23 @@ export interface DiagnosticImage {
     mime: 'jpg' | 'png';
 }
 export interface SendDiagnosticParams {
+    /** Backend base URL (same value the SDK was initialised with). */
+    baseUrl: string;
+    /** Demo session id (informational; the endpoint is unauthenticated). */
+    sessionId?: string;
     scan: ScanDataForReport;
     sdkVersion: string;
-    sessionId?: string;
     /** base64 images to attach (MRZ side / front / face / NFC chip face). */
     images?: DiagnosticImage[];
 }
 export interface SendResult {
-    shared: boolean;
-    /** True when the user dismissed the share sheet (not an error). */
-    dismissed?: boolean;
+    /** True when the report was uploaded and stored. */
+    uploaded: boolean;
 }
 /**
- * Build the report, stage attachments, and present the share sheet. Returns
- * { shared } — false on error, with `dismissed` set when the user cancelled.
+ * Build the report and upload it (over HTTPS) to the demo-diagnostics endpoint.
+ * Returns { uploaded } — false on any error (best-effort; a failed report must
+ * never disrupt the user's flow).
  */
 export declare const sendDiagnosticReport: (params: SendDiagnosticParams) => Promise<SendResult>;
 //# sourceMappingURL=sendDiagnosticReport.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sendDiagnosticReport.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/sendDiagnosticReport.ts"],"names":[],"mappings":"AAqBA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAyB5B;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAAO,OAA8B,CAAC;AAE/E,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAcD,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,mEAAmE;IACnE,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,oBAAoB,KAC3B,OAAO,CAAC,UAAU,CAsEpB,CAAC"}
+{"version":3,"file":"sendDiagnosticReport.d.ts","sourceRoot":"","sources":["../../../../../src/Shared/Libs/sendDiagnosticReport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,gCAAgC,CAAC;AAGxC,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAI5B,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAKD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,oBAAoB,KAC3B,OAAO,CAAC,UAAU,CA6EpB,CAAC"}

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

@@ -48,11 +48,10 @@ 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;
+    'diagnosticReport.sentTitle': string;
+    'diagnosticReport.sentBody': string;
+    'diagnosticReport.failedTitle': string;
+    'diagnosticReport.failedBody': string;
     'livenessDetectionScreen.guideHeader': string;
     'livenessDetectionScreen.guideText': string;
     'livenessDetectionScreen.guidePoint1': 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,wBAmRE"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAgRE"}

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

@@ -48,11 +48,10 @@ 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;
+    'diagnosticReport.sentTitle': string;
+    'diagnosticReport.sentBody': string;
+    'diagnosticReport.failedTitle': string;
+    'diagnosticReport.failedBody': string;
     'livenessDetectionScreen.guideHeader': string;
     'livenessDetectionScreen.guideText': string;
     'livenessDetectionScreen.guidePoint1': 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,wBAsRE"}
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAmRE"}

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustchex/react-native-sdk",
-  "version": "1.489.0",
+  "version": "1.490.1",
   "description": "Trustchex mobile app react native SDK for android or ios devices",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -169,7 +169,6 @@
     "react-native-nfc-manager": ">=3.16.2",
     "react-native-safe-area-context": ">=5.5.2",
     "react-native-screens": ">=4.18.0",
-    "react-native-share": ">=12.0.0",
     "react-native-sse": ">=1.1.0",
     "react-native-svg": ">=15.12.0",
     "react-native-tts": ">=4.1.1",
@@ -217,9 +216,6 @@
     "react-native-screens": {
       "optional": false
     },
-    "react-native-share": {
-      "optional": true
-    },
     "react-native-sse": {
       "optional": false
     },

package/src/Screens/Static/ResultScreen.tsx

@@ -1082,6 +1082,7 @@ const ResultScreen = () => {
                 {t('resultScreen.demoStartOver')}
               </StyledButton>
               <DiagnosticReportButton
+                baseUrl={appContext.baseUrl}
                 sessionId={appContext.identificationInfo?.sessionId}
                 scan={{
                   documentType:

package/src/Shared/Components/DiagnosticReportButton.tsx

@@ -4,44 +4,44 @@ import { useTranslation } from 'react-i18next';
 import StyledButton from './StyledButton';
 import {
   sendDiagnosticReport,
-  isDiagnosticSharingAvailable,
   type DiagnosticImage,
 } from '../Libs/sendDiagnosticReport';
 import type { ScanDataForReport } from '../Libs/diagnosticReport';
 import { SDK_VERSION } from '../../version';
 
 export interface DiagnosticReportButtonProps {
-  scan: ScanDataForReport;
+  /** Backend base URL the SDK was initialised with. */
+  baseUrl: string;
   sessionId?: string;
+  scan: ScanDataForReport;
   images?: DiagnosticImage[];
 }
 
 /**
  * "Report a scanning issue" button for the result screen.
  *
- * Shows a brief notice describing what will be shared (the draft itself is the
- * user's review/consent step), then opens the OS share sheet — the user picks
- * email / WhatsApp / Drive / etc. and sends the diagnostic bundle to support.
- * Self-contained so the result screen only needs to render it with the scan
- * data + captured images.
+ * Shows a brief notice describing what will be shared (acting as the user's
+ * consent step), then uploads the diagnostic bundle (technical signals +
+ * scanned data + captured images) to the backend, encrypted in transit and at
+ * rest. Operators view and download the reports from the dashboard.
+ *
+ * Hidden when there's no session/baseUrl to upload to (e.g. before init).
  */
 const DiagnosticReportButton: React.FC<DiagnosticReportButtonProps> = ({
-  scan,
+  baseUrl,
   sessionId,
+  scan,
   images,
 }) => {
   const { t } = useTranslation();
   const [sending, setSending] = useState(false);
 
-  // `react-native-share` is optional — hide the button entirely when the host
-  // app hasn't installed it, so apps that don't want diagnostics see no UI.
-  if (!isDiagnosticSharingAvailable()) {
+  if (!baseUrl || !sessionId) {
     return null;
   }
 
   const onPress = () => {
     if (sending) return;
-    // Brief notice — the share draft is the actual review/consent step.
     Alert.alert(
       t('diagnosticReport.noticeTitle'),
       t('diagnosticReport.noticeBody'),
@@ -52,12 +52,21 @@ const DiagnosticReportButton: React.FC<DiagnosticReportButtonProps> = ({
           onPress: async () => {
             setSending(true);
             try {
-              await sendDiagnosticReport({
+              const { uploaded } = await sendDiagnosticReport({
+                baseUrl,
+                sessionId,
                 scan,
                 sdkVersion: SDK_VERSION,
-                sessionId,
                 images,
               });
+              Alert.alert(
+                uploaded
+                  ? t('diagnosticReport.sentTitle')
+                  : t('diagnosticReport.failedTitle'),
+                uploaded
+                  ? t('diagnosticReport.sentBody')
+                  : t('diagnosticReport.failedBody')
+              );
             } finally {
               setSending(false);
             }

package/src/Shared/Libs/diagnosticAuth.ts

@@ -0,0 +1,47 @@
+import { Buffer } from 'buffer';
+import { hmac } from '@noble/hashes/hmac';
+import { sha256 } from '@noble/hashes/sha2';
+
+/**
+ * Authenticity signing for the demo-diagnostics upload.
+ *
+ * Demo reports have no session/account to authenticate against, so the SDK signs
+ * each upload with HMAC-SHA256 over `timestamp.nonce.rawBody` using a shared
+ * secret. The backend recomputes and rejects mismatches and stale timestamps
+ * (replay). The secret ships in the SDK, so it's an obfuscation barrier (paired
+ * with server rate limiting), not a true secret — rotate via the env var on both
+ * sides. MUST stay byte-for-byte in sync with web-app/src/lib/diagnostic-hmac.ts.
+ */
+const SECRET =
+  process.env.TRUSTCHEX_DIAGNOSTICS_SECRET ??
+  'tcx-diag-v1-2f9c4a7e8b1d4f63a05e9c7b3d61f8a2';
+
+export interface DiagnosticSignature {
+  timestamp: string;
+  nonce: string;
+  signature: string;
+}
+
+const randomNonce = (): string => {
+  // 16 random bytes as hex. crypto.getRandomValues is polyfilled by
+  // react-native-get-random-values (already imported in crypto.utils).
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  return Buffer.from(bytes).toString('hex');
+};
+
+/** Sign a raw JSON body for the demo-diagnostics endpoint. */
+export const signDiagnosticBody = (rawBody: string): DiagnosticSignature => {
+  const timestamp = Date.now().toString();
+  const nonce = randomNonce();
+  const mac = hmac(
+    sha256,
+    Buffer.from(SECRET, 'utf-8'),
+    Buffer.from(`${timestamp}.${nonce}.${rawBody}`, 'utf-8')
+  );
+  return {
+    timestamp,
+    nonce,
+    signature: Buffer.from(mac).toString('hex'),
+  };
+};

package/src/Shared/Libs/sendDiagnosticReport.ts

@@ -1,58 +1,30 @@
 /**
- * Assembles and shares the support diagnostic report.
+ * Assembles and uploads the support diagnostic report to the backend.
  *
- * `react-native-share` is an OPTIONAL dependency: the host app opts into the
- * diagnostic feature by installing it. When it's present we open the OS share
- * sheet with the full report (the user picks email / WhatsApp / Drive / etc. and
- * reviews before sending); when it's absent the feature is silently unavailable
- * — `isDiagnosticSharingAvailable()` returns false and the result-screen button
- * renders nothing, so apps that don't want it incur no dependency.
+ * This runs from the SDK's DEMO flow only, which is simulated client-side and
+ * has no real verification session or account — so there's no session key to
+ * encrypt with and nothing to authenticate against. The report is POSTed
+ * unauthenticated to the global demo-diagnostics endpoint over HTTPS (encrypted
+ * in transit); the backend encrypts the PII fields at rest. Internal developers
+ * view and download the reports from a hidden dashboard page.
  *
- * Attached files (staged to a temp dir via react-native-fs, already an SDK dep):
- *  - `diagnostics.json` — technical signals (device, camera, MRZ, NFC steps),
- *  - `scan-data.json`   — the scanned identity data (PII; user reviews it),
- *  - the captured document/face images.
- *
- * The readable summary rides as the share `message` so it's visible in the
- * draft regardless of the chosen app.
+ * Uploaded payload (one JSON body):
+ *  - non-PII technical metadata (platform, sdkVersion, documentType,
+ *    nfcErrorCode, paceFallbackReason, succeeded) for the list/filter,
+ *  - `diagnosticsJson` — technical signals (device, camera, MRZ, NFC steps),
+ *  - `scanDataJson`   — the scanned identity data (PII),
+ *  - `images`         — the captured document/face images (base64, PII).
  */
-import RNFS from 'react-native-fs';
+import 'react-native-get-random-values';
 import { diagnostics } from './diagnostics';
 import { gatherDeviceDetails } from './native-device-info.utils';
 import {
   buildDiagnosticReport,
   type ScanDataForReport,
 } from './diagnosticReport';
+import { signDiagnosticBody } from './diagnosticAuth';
 import { logError } from './debug.utils';
 
-// `react-native-share` is OPTIONAL. Load it softly so the SDK bundles and runs
-// without it; only host apps that installed it get the diagnostic feature. A
-// static `import` would make Metro fail to resolve the module when it's absent,
-// so we use a guarded require and keep the reference typed loosely.
-type ShareModule = {
-  open: (options: Record<string, unknown>) => Promise<unknown>;
-};
-
-let shareModule: ShareModule | null | undefined;
-
-const loadShare = (): ShareModule | null => {
-  if (shareModule !== undefined) return shareModule;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const mod = require('react-native-share');
-    shareModule = (mod?.default ?? mod) as ShareModule;
-  } catch {
-    shareModule = null; // not installed — feature unavailable
-  }
-  return shareModule;
-};
-
-/**
- * Whether diagnostic sharing is available (i.e. `react-native-share` is
- * installed in the host app). The result-screen button hides itself when false.
- */
-export const isDiagnosticSharingAvailable = (): boolean => loadShare() != null;
-
 export interface DiagnosticImage {
   /** Stable file name without extension, e.g. "mrz-side". */
   name: string;
@@ -61,105 +33,106 @@ export interface DiagnosticImage {
 }
 
 export interface SendDiagnosticParams {
+  /** Backend base URL (same value the SDK was initialised with). */
+  baseUrl: string;
+  /** Demo session id (informational; the endpoint is unauthenticated). */
+  sessionId?: string;
   scan: ScanDataForReport;
   sdkVersion: string;
-  sessionId?: string;
   /** base64 images to attach (MRZ side / front / face / NFC chip face). */
   images?: DiagnosticImage[];
 }
 
-
-const writeTemp = async (
-  dir: string,
-  name: string,
-  data: string,
-  encoding: 'utf8' | 'base64'
-): Promise<string> => {
-  const path = `${dir}/${name}`;
-  await RNFS.writeFile(path, data, encoding);
-  return path.startsWith('file://') ? path : `file://${path}`;
-};
-
 export interface SendResult {
-  shared: boolean;
-  /** True when the user dismissed the share sheet (not an error). */
-  dismissed?: boolean;
+  /** True when the report was uploaded and stored. */
+  uploaded: boolean;
 }
 
+const mimeToType = (mime: 'jpg' | 'png'): string =>
+  mime === 'png' ? 'image/png' : 'image/jpeg';
+
 /**
- * Build the report, stage attachments, and present the share sheet. Returns
- * { shared } — false on error, with `dismissed` set when the user cancelled.
+ * Build the report and upload it (over HTTPS) to the demo-diagnostics endpoint.
+ * Returns { uploaded } — false on any error (best-effort; a failed report must
+ * never disrupt the user's flow).
  */
 export const sendDiagnosticReport = async (
   params: SendDiagnosticParams
 ): Promise<SendResult> => {
-  const share = loadShare();
-  if (!share) {
-    // Optional dependency not installed — nothing to do.
-    return { shared: false };
+  const { baseUrl, sessionId, scan, sdkVersion, images = [] } = params;
+  if (!baseUrl) {
+    return { uploaded: false };
   }
-  const { scan, sdkVersion, sessionId, images = [] } = params;
+
   const now = Date.now();
   const iso = new Date(now).toISOString();
 
-  const device = await gatherDeviceDetails();
-  const report = buildDiagnosticReport({
-    diag: diagnostics.snapshot(now, iso),
-    device,
-    scan,
-    sdkVersion,
-    sessionId,
-  });
-
-  const dir = `${RNFS.TemporaryDirectoryPath}/trustchex-diagnostics-${now}`;
   try {
-    await RNFS.mkdir(dir);
-    const urls: string[] = [];
-    urls.push(
-      await writeTemp(dir, 'diagnostics.json', report.diagnosticsJson, 'utf8')
-    );
-    urls.push(
-      await writeTemp(dir, 'scan-data.json', report.scanDataJson, 'utf8')
-    );
-    for (const img of images) {
-      if (!img.base64) continue;
-      urls.push(
-        await writeTemp(dir, `${img.name}.${img.mime}`, img.base64, 'base64')
-      );
-    }
+    const device = await gatherDeviceDetails();
+    const snapshot = diagnostics.snapshot(now, iso);
+    const report = buildDiagnosticReport({
+      diag: snapshot,
+      device,
+      scan,
+      sdkVersion,
+      sessionId,
+    });
+
+    // Queryable, non-PII technical metadata for the dashboard list/filter.
+    const nfc = snapshot.nfc;
+    const failingSw = nfc.failureStep
+      ? nfc.steps.find((s) => s.step === nfc.failureStep && !s.ok)?.sw
+      : undefined;
+    const nfcErrorCode =
+      nfc.attempted && !nfc.succeeded
+        ? `NFC-${(nfc.errorCategory ?? 'reading_error').toUpperCase()}${failingSw ? `-${failingSw}` : ''}`
+        : null;
+
+    const payload = {
+      // metadata (stored in plaintext, no PII)
+      platform: device.platform,
+      osVersion: device.systemVersion,
+      sdkVersion,
+      documentType: scan.documentType ?? snapshot.documentType ?? null,
+      dataSource: scan.dataSource ?? snapshot.dataSource ?? null,
+      nfcErrorCode,
+      paceFallbackReason: nfc.paceFallbackReason ?? null,
+      succeeded: nfc.attempted ? nfc.succeeded : null,
+      // full report (PII, encrypted at rest by the backend)
+      diagnosticsJson: report.diagnosticsJson,
+      scanDataJson: report.scanDataJson,
+      images: images
+        .filter((img) => img.base64)
+        .map((img) => ({
+          name: img.name,
+          base64: img.base64,
+          mimeType: mimeToType(img.mime),
+        })),
+    };
+
+    // Sign the EXACT body bytes so the backend can verify authenticity. Use
+    // fetch directly (httpClient doesn't expose custom headers / raw body).
+    const rawBody = JSON.stringify(payload);
+    const { timestamp, nonce, signature } = signDiagnosticBody(rawBody);
+
+    const response = await fetch(`${baseUrl}/api/app/mobile/diagnostics`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Trustchex-Timestamp': timestamp,
+        'X-Trustchex-Nonce': nonce,
+        'X-Trustchex-Signature': signature,
+      },
+      body: rawBody,
+    });
 
-    try {
-      await share.open({
-        title: report.subject,
-        subject: report.subject, // used by email targets
-        message: report.body,
-        urls,
-        // Per-file MIME types so targets render attachments correctly.
-        filenames: urls.map((u) => u.split('/').pop() ?? 'attachment'),
-        failOnCancel: false,
-      });
-      return { shared: true };
-    } catch (shareErr) {
-      // react-native-share throws on user cancel unless failOnCancel:false; treat
-      // a cancel as a non-error dismissal.
-      const msg =
-        shareErr instanceof Error ? shareErr.message : String(shareErr);
-      if (/cancel|dismiss|user did not share/i.test(msg)) {
-        return { shared: false, dismissed: true };
-      }
-      throw shareErr;
-    }
+    return { uploaded: response.ok };
   } catch (e) {
     logError(
       'Diagnostics',
-      'Failed to share diagnostic report',
+      'Failed to upload diagnostic report',
       e instanceof Error ? e.message : String(e)
     );
-    return { shared: false };
-  } finally {
-    // Best-effort cleanup — temp files are short-lived.
-    setTimeout(() => {
-      RNFS.unlink(dir).catch(() => {});
-    }, 60_000);
+    return { uploaded: false };
   }
 };

package/src/Translation/Resources/en.ts

@@ -54,18 +54,15 @@ export default {
   'resultScreen.demoVerbalConsentText': 'Text',
   'resultScreen.demoStartOver': 'Start Over',
   'diagnosticReport.button': 'Report a scanning issue',
-  'diagnosticReport.noticeTitle': 'Share diagnostic report',
+  'diagnosticReport.noticeTitle': 'Report a scanning issue',
   'diagnosticReport.noticeBody':
-    'This opens a draft with your scan data, document images and technical details so support can help resolve a scanning issue. Review it before sending.',
+    'This sends your scan data, document images and technical details to support so they can help resolve a scanning issue.',
   'diagnosticReport.continue': 'Continue',
   'diagnosticReport.cancel': 'Cancel',
-  'diagnosticReport.shareFailedTitle': "Couldn't open the share sheet",
-  'diagnosticReport.shareFailedBody':
-    "We couldn't attach the report to share. Send it securely to support instead?",
-  'diagnosticReport.uploadAction': 'Send to support',
-  'diagnosticReport.uploadSuccess': 'Diagnostic report sent to support.',
-  'diagnosticReport.uploadFailed':
-    "Couldn't send the report. Please try again later.",
+  'diagnosticReport.sentTitle': 'Report sent',
+  'diagnosticReport.sentBody': 'Your diagnostic report was sent to support. Thank you.',
+  'diagnosticReport.failedTitle': "Couldn't send the report",
+  'diagnosticReport.failedBody': 'Please try again later.',
   'livenessDetectionScreen.guideHeader': 'Face Verification',
   'livenessDetectionScreen.guideText':
     'Please ensure the following for best results:',

package/src/Translation/Resources/tr.ts

@@ -54,18 +54,15 @@ export default {
   'resultScreen.demoVerbalConsentText': 'Metin',
   'resultScreen.demoStartOver': 'Baştan Başla',
   'diagnosticReport.button': 'Tarama sorununu bildir',
-  'diagnosticReport.noticeTitle': 'Tanılama raporu paylaş',
+  'diagnosticReport.noticeTitle': 'Tarama sorununu bildir',
   'diagnosticReport.noticeBody':
-    'Bu işlem; tarama verilerinizi, belge görüntülerinizi ve teknik ayrıntıları içeren bir taslak açar; böylece destek ekibi tarama sorununu çözebilir. Göndermeden önce gözden geçirin.',
+    'Bu işlem; tarama verilerinizi, belge görüntülerinizi ve teknik ayrıntıları destek ekibine gönderir; böylece tarama sorununu çözebilirler.',
   'diagnosticReport.continue': 'Devam et',
   'diagnosticReport.cancel': 'İptal',
-  'diagnosticReport.shareFailedTitle': 'Paylaşım ekranı açılamadı',
-  'diagnosticReport.shareFailedBody':
-    'Raporu paylaşmak için ekleyemedik. Bunun yerine destek ekibine güvenli şekilde gönderelim mi?',
-  'diagnosticReport.uploadAction': 'Desteğe gönder',
-  'diagnosticReport.uploadSuccess': 'Tanılama raporu destek ekibine gönderildi.',
-  'diagnosticReport.uploadFailed':
-    'Rapor gönderilemedi. Lütfen daha sonra tekrar deneyin.',
+  'diagnosticReport.sentTitle': 'Rapor gönderildi',
+  'diagnosticReport.sentBody': 'Tanılama raporunuz destek ekibine gönderildi. Teşekkürler.',
+  'diagnosticReport.failedTitle': 'Rapor gönderilemedi',
+  'diagnosticReport.failedBody': 'Lütfen daha sonra tekrar deneyin.',
   'livenessDetectionScreen.guideHeader': 'Yüz Doğrulaması',
   'livenessDetectionScreen.guideText':
     'En iyi sonuç için lütfen şunları sağlayın:',

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.489.0';
+export const SDK_VERSION = '1.490.1';