@switchlabs/verify-ai-react-native 2.5.6 → 2.5.8

package/README.md

@@ -1,6 +1,32 @@
 # @switchlabs/verify-ai-react-native
 
-React Native SDK for Verify AI photo verification.
+Send a photo and a policy, get back a pass/fail verdict with a confidence
+value, the criteria that failed, and human-readable reasoning. Built for
+end-of-ride parking compliance, vehicle and equipment condition and damage
+grading, proof of delivery, and rental return checks.
+
+The SDK wraps live camera capture (no gallery-picker path in the scanner
+flow), on-device pre-screening, an offline queue, and the REST API.
+
+```tsx
+const result = await verify({ image: base64, policy: 'scooter_parking' });
+if (result && !result.is_compliant) {
+  console.log(result.violation_reasons, result.feedback);
+}
+```
+
+**Try it before you install anything:** upload a photo at
+[verify.switchlabs.dev/demo](https://verify.switchlabs.dev/demo). No account,
+no card.
+
+**Get a key:** [free sandbox](https://verify.switchlabs.dev/login?mode=signup)
+with $5 of credit and no credit card. Keys start with `vai_` and are sent in an
+`X-API-Key` header.
+
+**Pricing:** $0.008 per standard verification for the first 100,000 in a
+calendar month, $0.006 from 100,001 to 1,000,000, and $0.005 above 1,000,000.
+No platform fee, no monthly minimum, no annual contract.
+[Full pricing](https://verify.switchlabs.dev/pricing).
 
 ## Install
 

package/lib/client/index.js

@@ -2,6 +2,13 @@ import { TelemetryReporter } from '../telemetry/TelemetryReporter';
 import { SDK_VERSION } from '../version';
 const DEFAULT_BASE_URL = 'https://verify.switchlabs.dev/api/v1';
 const DEFAULT_TIMEOUT = 60000;
+const MAX_IN_PROGRESS_RETRIES = 10;
+function retryAfterMs(value) {
+    if (value !== null && /^\d+$/.test(value.trim()))
+        return Number(value) * 1000;
+    const date = value ? Date.parse(value) : NaN;
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : 1000;
+}
 const VEHICLE_TYPE_LABELS = {
     scooter: 'Scooter',
     'e-bike': 'E-Bike',
@@ -150,17 +157,34 @@ export class VerifyAIClient {
         const method = (options.method || 'GET').toUpperCase();
         const url = `${this.baseUrl}${path}`;
         const context = { path, url, method };
+        const deadline = Date.now() + this.timeout;
         try {
-            const response = await fetch(url, {
-                ...options,
-                signal: controller.signal,
-                headers: {
-                    'X-API-Key': this.apiKey,
-                    ...options.headers,
-                },
-            });
-            const rawBody = await response.text();
-            const body = this.parseResponseBody(rawBody);
+            let response;
+            let body;
+            let retries = 0;
+            while (true) {
+                response = await fetch(url, {
+                    ...options,
+                    signal: controller.signal,
+                    headers: {
+                        'X-API-Key': this.apiKey,
+                        ...options.headers,
+                    },
+                });
+                const rawBody = await response.text();
+                body = this.parseResponseBody(rawBody);
+                const code = body && typeof body === 'object' ? body.code : undefined;
+                const key = new Headers(options.headers).get('Idempotency-Key');
+                const delay = retryAfterMs(response.headers.get('Retry-After'));
+                // Only replay an identical, explicitly keyed verification reservation.
+                // Keep one timeout budget and report errors only after retries exhaust.
+                if (path !== '/verify' || method !== 'POST' || !key || response.status !== 409 ||
+                    code !== 'idempotency_in_progress' || retries >= MAX_IN_PROGRESS_RETRIES ||
+                    delay >= deadline - Date.now() || controller.signal.aborted)
+                    break;
+                retries += 1;
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
             if (!response.ok) {
                 const errorBody = (body && typeof body === 'object' ? body : null);
                 throw this.buildRequestError(stringifyErrorMessage(errorBody?.error, `Request failed with status ${response.status}`), response.status, context, {

package/lib/components/VerifyAIScanner.js

@@ -8,7 +8,7 @@ import { SDK_VERSION } from '../version';
 import { BikeOverlay } from './BikeOverlay';
 import { ScooterOverlay } from './ScooterOverlay';
 import { ANDROID_ACCELEROMETER_AXIS_DOMINANCE_THRESHOLD, classifyAndroidAccelerometerOrientation, getOverlayRotationDeg, } from './scannerOrientation';
-import { CAMERA_CAPTURE_RETRY_DELAY_MS, getCameraCaptureRetryPlan, } from './cameraCaptureRetry';
+import { CAMERA_CAPTURE_RETRY_DELAY_MS, getCameraCaptureRetryPlan, waitForCameraCaptureRetry, } from './cameraCaptureRetry';
 /** Quality used when expo-image-manipulator is not available (lower = smaller). */
 const FALLBACK_QUALITY = 0.65;
 /** Quality used when expo-image-manipulator IS available (resize handles size). */
@@ -79,9 +79,6 @@ function createScannerError(message, code, name) {
     error.code = code;
     return error;
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 function createScannerSessionId() {
     return `scan_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -224,6 +221,10 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
     const terminalResultDeliveredRef = useRef(false);
     const appStateRef = useRef(AppState.currentState);
     const cameraReadyRef = useRef(false);
+    const cameraGenerationRef = useRef(0);
+    const scannerMountedRef = useRef(true);
+    const terminatedRef = useRef(false);
+    const renderedCameraGeneration = cameraGenerationRef.current;
     const cameraEverReadyRef = useRef(false);
     const cameraInitFailedRef = useRef(false);
     const permissionDeniedTrackedRef = useRef(false);
@@ -365,6 +366,7 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
         setTorchRetrySuppressed(nextSuppressed);
     }, []);
     useEffect(() => {
+        scannerMountedRef.current = true;
         const reporter = telemetryRef.current;
         if (reporter) {
             console.log(`VerifyAI[${SDK_VERSION}]: scanner telemetry attached ` +
@@ -385,6 +387,10 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
             }),
         });
         return () => {
+            scannerMountedRef.current = false;
+            cameraReadyRef.current = false;
+            if (startupRemountTimerRef.current)
+                clearTimeout(startupRemountTimerRef.current);
             const activeTelemetry = telemetryRef.current;
             activeTelemetry?.track('camera_scanner_disposed', {
                 component: 'scanner',
@@ -401,6 +407,7 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
         }
         setCameraReady(false);
         cameraReadyRef.current = false;
+        const generation = ++cameraGenerationRef.current;
         cameraStartupAttemptStartedAtRef.current = Date.now();
         if (opts.log) {
             console.warn(`VerifyAI[${SDK_VERSION}]: remounting camera reason=${reason} ` +
@@ -408,6 +415,8 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
                 `torchRetrySuppressed=${torchRetrySuppressedRef.current ? 1 : 0}`);
         }
         const remount = () => {
+            if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active' || cameraGenerationRef.current !== generation)
+                return;
             setCameraKey((k) => k + 1);
             setCameraMounted(true);
             startupRemountTimerRef.current = null;
@@ -688,6 +697,9 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
     }, []);
     // Release camera (and torch) when a terminal result is reached or on unmount.
     const releaseCamera = useCallback(() => {
+        terminatedRef.current = true;
+        cameraReadyRef.current = false;
+        cameraGenerationRef.current++;
         setTerminated(true);
         pausePreview();
     }, [pausePreview]);
@@ -735,7 +747,9 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
         onClose?.(terminalResultRef.current ?? result);
     }, [onClose, result]);
     // Camera init callbacks
-    const onCameraReady = useCallback(() => {
+    const onCameraReady = useCallback((generation) => {
+        if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active' || generation !== cameraGenerationRef.current)
+            return;
         const readyAt = new Date().toISOString();
         const startupTotalElapsedMs = Date.now() - cameraStartupStartedAtRef.current;
         const startupAttemptElapsedMs = Date.now() - cameraStartupAttemptStartedAtRef.current;
@@ -968,6 +982,10 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
             setTimeout(() => setStatus('idle'), 2000);
             return;
         }
+        if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active') {
+            captureIntentPendingRef.current = false;
+            return;
+        }
         setStatus('capturing');
         setTorchSuppressedForRetry(false);
         setResult(null);
@@ -978,7 +996,12 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
             clearTimeout(terminalResultTimerRef.current);
             terminalResultTimerRef.current = null;
         }
+        let captureCancelled = false;
         let nativeCaptureAttempts = 0;
+        let nativeCaptureElapsedMs = null;
+        let nativeCaptureReadyAgeMs = null;
+        let firstNativeCaptureElapsedMs = null;
+        let firstNativeCaptureReadyAgeMs = null;
         let captureRetryAttempted = false;
         let captureRetryReady = false;
         let captureRetryTorchSuppressed = false;
@@ -1025,39 +1048,59 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
             catch {
                 // Not installed — fall back to camera-only base64 below
             }
-            const waitForCameraReady = async (timeoutMs) => {
-                const start = Date.now();
-                while (Date.now() - start < timeoutMs) {
-                    if (cameraReadyRef.current && cameraRef.current) {
-                        return true;
-                    }
-                    await sleep(100);
-                }
-                return cameraReadyRef.current && !!cameraRef.current;
-            };
             const takePictureWithRetry = async (options, requiredField) => {
                 let lastError = null;
+                let preparedRetryCamera = null;
+                let preparedRetryGeneration = null;
                 for (let attempt = 1; attempt <= 2; attempt++) {
+                    if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active') {
+                        captureCancelled = true;
+                        throw createScannerError('Camera capture cancelled', CAMERA_NOT_READY_ERROR_CODE, 'CameraCaptureCancelled');
+                    }
+                    const attemptCamera = cameraRef.current;
+                    if (!attemptCamera || !cameraReadyRef.current ||
+                        (attempt === 2 && (attemptCamera !== preparedRetryCamera || cameraGenerationRef.current !== preparedRetryGeneration))) {
+                        throw lastError ?? createScannerError('Camera is not ready for capture', CAMERA_NOT_READY_ERROR_CODE, 'CameraNotReady');
+                    }
+                    const attemptStartedAt = Date.now();
+                    const attemptGeneration = cameraGenerationRef.current;
+                    nativeCaptureReadyAgeMs = lastCameraReadyAtRef.current ? attemptStartedAt - Date.parse(lastCameraReadyAtRef.current) : null;
                     nativeCaptureAttempts = attempt;
                     try {
-                        const photo = await cameraRef.current?.takePictureAsync(options);
+                        const photo = await attemptCamera?.takePictureAsync(options);
+                        if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active' ||
+                            cameraGenerationRef.current !== attemptGeneration || cameraRef.current !== attemptCamera) {
+                            captureCancelled = true;
+                            throw createScannerError('Camera capture cancelled', CAMERA_NOT_READY_ERROR_CODE, 'CameraCaptureCancelled');
+                        }
+                        nativeCaptureElapsedMs = Date.now() - attemptStartedAt;
+                        if (attempt === 1) {
+                            firstNativeCaptureElapsedMs = nativeCaptureElapsedMs;
+                            firstNativeCaptureReadyAgeMs = nativeCaptureReadyAgeMs;
+                        }
                         if (!photo?.[requiredField]) {
                             throw createScannerError('Failed to capture photo', CAMERA_CAPTURE_ERROR_CODE, 'CameraCaptureError');
                         }
                         return photo;
                     }
                     catch (captureErr) {
+                        nativeCaptureElapsedMs = Date.now() - attemptStartedAt;
+                        if (attempt === 1) {
+                            firstNativeCaptureElapsedMs = nativeCaptureElapsedMs;
+                            firstNativeCaptureReadyAgeMs = nativeCaptureReadyAgeMs;
+                        }
                         const normalized = normalizeScannerError(captureErr);
                         lastError = normalized;
                         lastNativeCaptureErrorMessage = normalized.message;
-                        if (attempt === 1 && isNativeCameraCaptureError(normalized) && !terminated) {
+                        if (attempt === 1 && isNativeCameraCaptureError(normalized) && scannerMountedRef.current && !terminatedRef.current && appStateRef.current === 'active') {
                             captureRetryAttempted = true;
                             const retryPlan = getCameraCaptureRetryPlan(Platform.OS, !!enableTorch);
                             captureRetryTorchSuppressed = retryPlan.suppressTorch;
                             captureRetrySettleDelayMs = retryPlan.settleDelayMs;
                             captureRetryRemountBackoffMs = retryPlan.remountBackoffMs;
                             captureRetryReadyTimeoutMs = retryPlan.readyTimeoutMs;
-                            const retryAt = new Date().toISOString();
+                            const retryRequestedAt = Date.now();
+                            const retryAt = new Date(retryRequestedAt).toISOString();
                             lastCaptureRetryAtRef.current = retryAt;
                             cameraRemountCountRef.current++;
                             if (captureRetryTorchSuppressed) {
@@ -1066,8 +1109,16 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
                             requestCameraRemount('capture_retry', captureRetryRemountBackoffMs > 0
                                 ? { backoffMs: captureRetryRemountBackoffMs }
                                 : undefined);
-                            await sleep(captureRetrySettleDelayMs);
-                            captureRetryReady = await waitForCameraReady(captureRetryReadyTimeoutMs);
+                            const retryGeneration = cameraGenerationRef.current;
+                            const retryCamera = await waitForCameraCaptureRetry(() => ({ camera: cameraRef.current, generation: cameraGenerationRef.current,
+                                ready: cameraReadyRef.current, active: scannerMountedRef.current && !terminatedRef.current && appStateRef.current === 'active' }), attemptCamera, retryGeneration, retryRequestedAt, retryPlan);
+                            captureRetryReady = !!retryCamera;
+                            preparedRetryCamera = retryCamera;
+                            preparedRetryGeneration = cameraGenerationRef.current;
+                            if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active' || cameraGenerationRef.current !== retryGeneration) {
+                                captureCancelled = true;
+                                throw normalized;
+                            }
                             telemetry?.track('camera_capture_retry', {
                                 component: 'scanner',
                                 error: normalized,
@@ -1084,6 +1135,8 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
                                     capture_retry_ready_timeout_ms: captureRetryReadyTimeoutMs,
                                     capture_retry_torch_suppressed: captureRetryTorchSuppressed,
                                     last_native_capture_error: lastNativeCaptureErrorMessage,
+                                    first_native_capture_elapsed_ms: firstNativeCaptureElapsedMs,
+                                    first_native_capture_ready_age_ms: firstNativeCaptureReadyAgeMs,
                                 }),
                             });
                             if (captureRetryReady) {
@@ -1159,6 +1212,10 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
                     resized: didResize ? 1 : 0,
                     has_manipulator: ImageManipulator ? 1 : 0,
                     native_capture_attempts: nativeCaptureAttempts,
+                    native_capture_elapsed_ms: nativeCaptureElapsedMs,
+                    native_capture_ready_age_ms: nativeCaptureReadyAgeMs,
+                    first_native_capture_elapsed_ms: firstNativeCaptureElapsedMs,
+                    first_native_capture_ready_age_ms: firstNativeCaptureReadyAgeMs,
                     capture_retry_attempted: captureRetryAttempted,
                     capture_retry_ready: captureRetryReady,
                     capture_retry_torch_suppressed: captureRetryTorchSuppressed,
@@ -1213,6 +1270,10 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
             }
         }
         catch (err) {
+            if (captureCancelled || !scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active') {
+                captureCancelled = true;
+                return;
+            }
             const error = normalizeScannerError(err);
             const terminalRequestError = isTerminalRequestError(error);
             if (terminalRequestError) {
@@ -1236,6 +1297,10 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
                         capture_attempt_id: captureAttemptId,
                         capture_sequence: captureSequence,
                         native_capture_attempts: nativeCaptureAttempts,
+                        native_capture_elapsed_ms: nativeCaptureElapsedMs,
+                        native_capture_ready_age_ms: nativeCaptureReadyAgeMs,
+                        first_native_capture_elapsed_ms: firstNativeCaptureElapsedMs,
+                        first_native_capture_ready_age_ms: firstNativeCaptureReadyAgeMs,
                         capture_retry_attempted: captureRetryAttempted,
                         capture_retry_ready: captureRetryReady,
                         capture_retry_torch_suppressed: captureRetryTorchSuppressed,
@@ -1253,7 +1318,10 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
         }
         finally {
             captureIntentPendingRef.current = false;
-            setTorchSuppressedForRetry(false);
+            if (scannerMountedRef.current)
+                setTorchSuppressedForRetry(false);
+            if (captureCancelled && scannerMountedRef.current && !terminatedRef.current)
+                setStatus('idle');
         }
     }, [status, exhausted, onCapture, onError, overlay?.maxAttempts, overlay?.autoApproveOnExhaust, releaseCamera, scheduleTerminalResult, buildScannerTelemetryMetadata, requestCameraRemount, telemetry, terminated, physicalOrientation, overlayRotationDeg, enableTorch, setTorchSuppressedForRetry]);
     // Expose capture to parent via ref
@@ -1268,7 +1336,7 @@ export function VerifyAIScanner({ onCapture, policy, onResult, onError, onClose,
     }
     const showBottomCard = status === 'success' || status === 'error';
     const shouldEnableTorch = !terminated && cameraReady && !!enableTorch && !torchRetrySuppressed;
-    return (_jsx(View, { style: [styles.container, style], children: cameraMounted && (_jsx(CameraView, { ref: cameraRef, style: styles.camera, facing: "back", enableTorch: shouldEnableTorch, onCameraReady: onCameraReady, onMountError: onMountError, responsiveOrientationWhenOrientationLocked: true, onResponsiveOrientationChanged: (event) => {
+    return (_jsx(View, { style: [styles.container, style], children: cameraMounted && (_jsx(CameraView, { ref: cameraRef, style: styles.camera, facing: "back", enableTorch: shouldEnableTorch, onCameraReady: () => onCameraReady(renderedCameraGeneration), onMountError: onMountError, responsiveOrientationWhenOrientationLocked: true, onResponsiveOrientationChanged: (event) => {
                 setPhysicalOrientation(event.orientation);
             }, children: _jsxs(View, { style: styles.overlay, children: [overlay?.title && (_jsx(View, { style: [styles.topBar, isLandscape && styles.topBarLandscape], children: _jsx(Text, { style: [
                                 styles.titleText,

package/lib/components/cameraCaptureRetry.d.ts

@@ -1,4 +1,5 @@
 export declare const CAMERA_CAPTURE_RETRY_DELAY_MS = 350;
+export declare const CAMERA_CAPTURE_RETRY_POST_READY_MS = 350;
 export declare const CAMERA_CAPTURE_RETRY_TORCH_SETTLE_MS = 800;
 export declare const IOS_CAMERA_CAPTURE_RETRY_READY_TIMEOUT_MS = 3000;
 export declare const ANDROID_CAMERA_CAPTURE_RETRY_READY_TIMEOUT_MS = 10000;
@@ -9,4 +10,12 @@ export interface CameraCaptureRetryPlan {
     settleDelayMs: number;
     suppressTorch: boolean;
 }
+export interface CameraCaptureRetryState<T> {
+    camera: T | null;
+    generation: number;
+    ready: boolean;
+    active: boolean;
+}
+/** Wait for a fresh camera, preserving the existing total-delay/deadline policy. */
+export declare function waitForCameraCaptureRetry<T>(readState: () => CameraCaptureRetryState<T>, previousCamera: T | null, generation: number, requestedAt: number, plan: CameraCaptureRetryPlan, sleep?: (ms: number) => Promise<void>, now?: () => number): Promise<T | null>;
 export declare function getCameraCaptureRetryPlan(platform: CameraCaptureRetryPlatform, torchRequested: boolean): CameraCaptureRetryPlan;

package/lib/components/cameraCaptureRetry.js

@@ -1,7 +1,28 @@
 export const CAMERA_CAPTURE_RETRY_DELAY_MS = 350;
+export const CAMERA_CAPTURE_RETRY_POST_READY_MS = 350;
 export const CAMERA_CAPTURE_RETRY_TORCH_SETTLE_MS = 800;
 export const IOS_CAMERA_CAPTURE_RETRY_READY_TIMEOUT_MS = 3000;
 export const ANDROID_CAMERA_CAPTURE_RETRY_READY_TIMEOUT_MS = 10000;
+/** Wait for a fresh camera, preserving the existing total-delay/deadline policy. */
+export async function waitForCameraCaptureRetry(readState, previousCamera, generation, requestedAt, plan, sleep = ms => new Promise(resolve => setTimeout(resolve, ms)), now = Date.now) {
+    // Previously readiness polling began only after the total settle delay.
+    const deadline = requestedAt + plan.settleDelayMs + plan.readyTimeoutMs;
+    let state = readState();
+    while (state.active && state.generation === generation &&
+        !(state.ready && state.camera && state.camera !== previousCamera)) {
+        if (now() >= deadline)
+            return null;
+        await sleep(Math.min(100, deadline - now()));
+        state = readState();
+    }
+    if (!state.active || state.generation !== generation || !state.ready || !state.camera)
+        return null;
+    const camera = state.camera;
+    const captureAt = Math.max(requestedAt + plan.settleDelayMs, now() + CAMERA_CAPTURE_RETRY_POST_READY_MS);
+    await sleep(Math.max(0, captureAt - now()));
+    state = readState();
+    return state.active && state.generation === generation && state.ready && state.camera === camera ? camera : null;
+}
 export function getCameraCaptureRetryPlan(platform, torchRequested) {
     const suppressTorch = torchRequested;
     return {

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "2.5.6";
+export declare const SDK_VERSION = "2.5.8";

package/lib/version.js

@@ -1 +1 @@
-export const SDK_VERSION = '2.5.6';
+export const SDK_VERSION = '2.5.8';

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@switchlabs/verify-ai-react-native",
-  "version": "2.5.6",
+  "version": "2.5.8",
   "description": "React Native SDK for Verify AI - photo verification with AI vision processing",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/levyelectric/verify.git",
-    "directory": "packages/verify-ai-react-native"
+  "homepage": "https://verify.switchlabs.dev/docs/sdks/react-native",
+  "bugs": {
+    "url": "https://verify.switchlabs.dev/contact"
   },
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -35,7 +34,12 @@
     "photo-verification",
     "ai-vision",
     "parking-compliance",
-    "damage-detection"
+    "damage-detection",
+    "proof-of-delivery",
+    "image-verification",
+    "vehicle-inspection",
+    "expo",
+    "photo-verification-api"
   ],
   "author": "Switch Labs",
   "license": "MIT",
@@ -86,5 +90,10 @@
     "react-native-fast-tflite": "^1.6.1",
     "typescript": "^5.5.0",
     "vitest": "^4.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/levyelectric/verify.git",
+    "directory": "packages/verify-ai-react-native"
   }
 }

package/src/client/index.ts

@@ -14,6 +14,13 @@ import { SDK_VERSION } from '../version';
 
 const DEFAULT_BASE_URL = 'https://verify.switchlabs.dev/api/v1';
 const DEFAULT_TIMEOUT = 60000;
+const MAX_IN_PROGRESS_RETRIES = 10;
+
+function retryAfterMs(value: string | null): number {
+  if (value !== null && /^\d+$/.test(value.trim())) return Number(value) * 1000;
+  const date = value ? Date.parse(value) : NaN;
+  return Number.isFinite(date) ? Math.max(0, date - Date.now()) : 1000;
+}
 
 const VEHICLE_TYPE_LABELS: Record<string, string> = {
   scooter: 'Scooter',
@@ -214,19 +221,35 @@ export class VerifyAIClient {
     const method = (options.method || 'GET').toUpperCase();
     const url = `${this.baseUrl}${path}`;
     const context: RequestContext = { path, url, method };
+    const deadline = Date.now() + this.timeout;
 
     try {
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal,
-        headers: {
-          'X-API-Key': this.apiKey,
-          ...options.headers,
-        },
-      });
-
-      const rawBody = await response.text();
-      const body = this.parseResponseBody(rawBody);
+      let response: Response;
+      let body: unknown;
+      let retries = 0;
+      while (true) {
+        response = await fetch(url, {
+          ...options,
+          signal: controller.signal,
+          headers: {
+            'X-API-Key': this.apiKey,
+            ...options.headers,
+          },
+        });
+
+        const rawBody = await response.text();
+        body = this.parseResponseBody(rawBody);
+        const code = body && typeof body === 'object' ? (body as VerifyAIError).code : undefined;
+        const key = new Headers(options.headers).get('Idempotency-Key');
+        const delay = retryAfterMs(response.headers.get('Retry-After'));
+        // Only replay an identical, explicitly keyed verification reservation.
+        // Keep one timeout budget and report errors only after retries exhaust.
+        if (path !== '/verify' || method !== 'POST' || !key || response.status !== 409 ||
+            code !== 'idempotency_in_progress' || retries >= MAX_IN_PROGRESS_RETRIES ||
+            delay >= deadline - Date.now() || controller.signal.aborted) break;
+        retries += 1;
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
 
       if (!response.ok) {
         const errorBody = (body && typeof body === 'object' ? body : null) as VerifyAIError | null;

package/src/components/VerifyAIScanner.tsx

@@ -35,6 +35,7 @@ import {
 import {
   CAMERA_CAPTURE_RETRY_DELAY_MS,
   getCameraCaptureRetryPlan,
+  waitForCameraCaptureRetry,
 } from './cameraCaptureRetry';
 
 /** Quality used when expo-image-manipulator is not available (lower = smaller). */
@@ -158,10 +159,6 @@ function createScannerError(message: string, code: string, name: string): ErrorW
   return error;
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 function createScannerSessionId(): string {
   return `scan_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -330,6 +327,10 @@ export function VerifyAIScanner({
   const terminalResultDeliveredRef = useRef(false);
   const appStateRef = useRef(AppState.currentState);
   const cameraReadyRef = useRef(false);
+  const cameraGenerationRef = useRef(0);
+  const scannerMountedRef = useRef(true);
+  const terminatedRef = useRef(false);
+  const renderedCameraGeneration = cameraGenerationRef.current;
   const cameraEverReadyRef = useRef(false);
   const cameraInitFailedRef = useRef(false);
   const permissionDeniedTrackedRef = useRef(false);
@@ -483,6 +484,7 @@ export function VerifyAIScanner({
   }, []);
 
   useEffect(() => {
+    scannerMountedRef.current = true;
     const reporter = telemetryRef.current;
     if (reporter) {
       console.log(
@@ -507,6 +509,9 @@ export function VerifyAIScanner({
     });
 
     return () => {
+      scannerMountedRef.current = false;
+      cameraReadyRef.current = false;
+      if (startupRemountTimerRef.current) clearTimeout(startupRemountTimerRef.current);
       const activeTelemetry = telemetryRef.current;
       activeTelemetry?.track('camera_scanner_disposed', {
         component: 'scanner',
@@ -531,6 +536,7 @@ export function VerifyAIScanner({
 
     setCameraReady(false);
     cameraReadyRef.current = false;
+    const generation = ++cameraGenerationRef.current;
     cameraStartupAttemptStartedAtRef.current = Date.now();
 
     if (opts.log) {
@@ -542,6 +548,7 @@ export function VerifyAIScanner({
     }
 
     const remount = () => {
+      if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active' || cameraGenerationRef.current !== generation) return;
       setCameraKey((k) => k + 1);
       setCameraMounted(true);
       startupRemountTimerRef.current = null;
@@ -868,6 +875,9 @@ export function VerifyAIScanner({
 
   // Release camera (and torch) when a terminal result is reached or on unmount.
   const releaseCamera = useCallback(() => {
+    terminatedRef.current = true;
+    cameraReadyRef.current = false;
+    cameraGenerationRef.current++;
     setTerminated(true);
     pausePreview();
   }, [pausePreview]);
@@ -920,7 +930,8 @@ export function VerifyAIScanner({
   }, [onClose, result]);
 
   // Camera init callbacks
-  const onCameraReady = useCallback(() => {
+  const onCameraReady = useCallback((generation: number) => {
+    if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active' || generation !== cameraGenerationRef.current) return;
     const readyAt = new Date().toISOString();
     const startupTotalElapsedMs = Date.now() - cameraStartupStartedAtRef.current;
     const startupAttemptElapsedMs = Date.now() - cameraStartupAttemptStartedAtRef.current;
@@ -1184,6 +1195,10 @@ export function VerifyAIScanner({
       return;
     }
 
+    if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active') {
+      captureIntentPendingRef.current = false;
+      return;
+    }
     setStatus('capturing');
     setTorchSuppressedForRetry(false);
     setResult(null);
@@ -1195,7 +1210,12 @@ export function VerifyAIScanner({
       terminalResultTimerRef.current = null;
     }
 
+    let captureCancelled = false;
     let nativeCaptureAttempts = 0;
+    let nativeCaptureElapsedMs: number | null = null;
+    let nativeCaptureReadyAgeMs: number | null = null;
+    let firstNativeCaptureElapsedMs: number | null = null;
+    let firstNativeCaptureReadyAgeMs: number | null = null;
     let captureRetryAttempted = false;
     let captureRetryReady = false;
     let captureRetryTorchSuppressed = false;
@@ -1245,27 +1265,40 @@ export function VerifyAIScanner({
         // Not installed — fall back to camera-only base64 below
       }
 
-      const waitForCameraReady = async (timeoutMs: number): Promise<boolean> => {
-        const start = Date.now();
-        while (Date.now() - start < timeoutMs) {
-          if (cameraReadyRef.current && cameraRef.current) {
-            return true;
-          }
-          await sleep(100);
-        }
-        return cameraReadyRef.current && !!cameraRef.current;
-      };
-
       const takePictureWithRetry = async (
         options: { base64?: boolean; quality?: number; exif?: boolean },
         requiredField: 'uri' | 'base64',
       ) => {
         let lastError: ErrorWithDetails | null = null;
+        let preparedRetryCamera: CameraView | null = null;
+        let preparedRetryGeneration: number | null = null;
 
         for (let attempt = 1; attempt <= 2; attempt++) {
+          if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active') {
+            captureCancelled = true;
+            throw createScannerError('Camera capture cancelled', CAMERA_NOT_READY_ERROR_CODE, 'CameraCaptureCancelled');
+          }
+          const attemptCamera = cameraRef.current;
+          if (!attemptCamera || !cameraReadyRef.current ||
+              (attempt === 2 && (attemptCamera !== preparedRetryCamera || cameraGenerationRef.current !== preparedRetryGeneration))) {
+            throw lastError ?? createScannerError('Camera is not ready for capture', CAMERA_NOT_READY_ERROR_CODE, 'CameraNotReady');
+          }
+          const attemptStartedAt = Date.now();
+          const attemptGeneration = cameraGenerationRef.current;
+          nativeCaptureReadyAgeMs = lastCameraReadyAtRef.current ? attemptStartedAt - Date.parse(lastCameraReadyAtRef.current) : null;
           nativeCaptureAttempts = attempt;
           try {
-            const photo = await cameraRef.current?.takePictureAsync(options);
+            const photo = await attemptCamera?.takePictureAsync(options);
+            if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active' ||
+                cameraGenerationRef.current !== attemptGeneration || cameraRef.current !== attemptCamera) {
+              captureCancelled = true;
+              throw createScannerError('Camera capture cancelled', CAMERA_NOT_READY_ERROR_CODE, 'CameraCaptureCancelled');
+            }
+            nativeCaptureElapsedMs = Date.now() - attemptStartedAt;
+            if (attempt === 1) {
+              firstNativeCaptureElapsedMs = nativeCaptureElapsedMs;
+              firstNativeCaptureReadyAgeMs = nativeCaptureReadyAgeMs;
+            }
             if (!photo?.[requiredField]) {
               throw createScannerError(
                 'Failed to capture photo',
@@ -1275,18 +1308,24 @@ export function VerifyAIScanner({
             }
             return photo;
           } catch (captureErr) {
+            nativeCaptureElapsedMs = Date.now() - attemptStartedAt;
+            if (attempt === 1) {
+              firstNativeCaptureElapsedMs = nativeCaptureElapsedMs;
+              firstNativeCaptureReadyAgeMs = nativeCaptureReadyAgeMs;
+            }
             const normalized = normalizeScannerError(captureErr);
             lastError = normalized;
             lastNativeCaptureErrorMessage = normalized.message;
 
-            if (attempt === 1 && isNativeCameraCaptureError(normalized) && !terminated) {
+            if (attempt === 1 && isNativeCameraCaptureError(normalized) && scannerMountedRef.current && !terminatedRef.current && appStateRef.current === 'active') {
               captureRetryAttempted = true;
               const retryPlan = getCameraCaptureRetryPlan(Platform.OS, !!enableTorch);
               captureRetryTorchSuppressed = retryPlan.suppressTorch;
               captureRetrySettleDelayMs = retryPlan.settleDelayMs;
               captureRetryRemountBackoffMs = retryPlan.remountBackoffMs;
               captureRetryReadyTimeoutMs = retryPlan.readyTimeoutMs;
-              const retryAt = new Date().toISOString();
+              const retryRequestedAt = Date.now();
+              const retryAt = new Date(retryRequestedAt).toISOString();
               lastCaptureRetryAtRef.current = retryAt;
               cameraRemountCountRef.current++;
               if (captureRetryTorchSuppressed) {
@@ -1298,8 +1337,19 @@ export function VerifyAIScanner({
                   ? { backoffMs: captureRetryRemountBackoffMs }
                   : undefined,
               );
-              await sleep(captureRetrySettleDelayMs);
-              captureRetryReady = await waitForCameraReady(captureRetryReadyTimeoutMs);
+              const retryGeneration = cameraGenerationRef.current;
+              const retryCamera: CameraView | null = await waitForCameraCaptureRetry<CameraView>(
+                () => ({camera: cameraRef.current, generation: cameraGenerationRef.current,
+                  ready: cameraReadyRef.current, active: scannerMountedRef.current && !terminatedRef.current && appStateRef.current === 'active'}),
+                attemptCamera, retryGeneration, retryRequestedAt, retryPlan,
+              );
+              captureRetryReady = !!retryCamera;
+              preparedRetryCamera = retryCamera;
+              preparedRetryGeneration = cameraGenerationRef.current;
+              if (!scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active' || cameraGenerationRef.current !== retryGeneration) {
+                captureCancelled = true;
+                throw normalized;
+              }
               telemetry?.track('camera_capture_retry', {
                 component: 'scanner',
                 error: normalized,
@@ -1316,6 +1366,8 @@ export function VerifyAIScanner({
                   capture_retry_ready_timeout_ms: captureRetryReadyTimeoutMs,
                   capture_retry_torch_suppressed: captureRetryTorchSuppressed,
                   last_native_capture_error: lastNativeCaptureErrorMessage,
+                  first_native_capture_elapsed_ms: firstNativeCaptureElapsedMs,
+                  first_native_capture_ready_age_ms: firstNativeCaptureReadyAgeMs,
                 }),
               });
               if (captureRetryReady) {
@@ -1417,6 +1469,10 @@ export function VerifyAIScanner({
           resized: didResize ? 1 : 0,
           has_manipulator: ImageManipulator ? 1 : 0,
           native_capture_attempts: nativeCaptureAttempts,
+          native_capture_elapsed_ms: nativeCaptureElapsedMs,
+          native_capture_ready_age_ms: nativeCaptureReadyAgeMs,
+          first_native_capture_elapsed_ms: firstNativeCaptureElapsedMs,
+          first_native_capture_ready_age_ms: firstNativeCaptureReadyAgeMs,
           capture_retry_attempted: captureRetryAttempted,
           capture_retry_ready: captureRetryReady,
           capture_retry_torch_suppressed: captureRetryTorchSuppressed,
@@ -1474,6 +1530,10 @@ export function VerifyAIScanner({
         setStatus('idle');
       }
     } catch (err) {
+      if (captureCancelled || !scannerMountedRef.current || terminatedRef.current || appStateRef.current !== 'active') {
+        captureCancelled = true;
+        return;
+      }
       const error = normalizeScannerError(err);
       const terminalRequestError = isTerminalRequestError(error);
       if (terminalRequestError) {
@@ -1500,6 +1560,10 @@ export function VerifyAIScanner({
               capture_attempt_id: captureAttemptId,
               capture_sequence: captureSequence,
               native_capture_attempts: nativeCaptureAttempts,
+              native_capture_elapsed_ms: nativeCaptureElapsedMs,
+              native_capture_ready_age_ms: nativeCaptureReadyAgeMs,
+              first_native_capture_elapsed_ms: firstNativeCaptureElapsedMs,
+              first_native_capture_ready_age_ms: firstNativeCaptureReadyAgeMs,
               capture_retry_attempted: captureRetryAttempted,
               capture_retry_ready: captureRetryReady,
               capture_retry_torch_suppressed: captureRetryTorchSuppressed,
@@ -1518,7 +1582,8 @@ export function VerifyAIScanner({
       }
     } finally {
       captureIntentPendingRef.current = false;
-      setTorchSuppressedForRetry(false);
+      if (scannerMountedRef.current) setTorchSuppressedForRetry(false);
+      if (captureCancelled && scannerMountedRef.current && !terminatedRef.current) setStatus('idle');
     }
   }, [status, exhausted, onCapture, onError, overlay?.maxAttempts, overlay?.autoApproveOnExhaust, releaseCamera, scheduleTerminalResult, buildScannerTelemetryMetadata, requestCameraRemount, telemetry, terminated, physicalOrientation, overlayRotationDeg, enableTorch, setTorchSuppressedForRetry]);
 
@@ -1554,7 +1619,7 @@ export function VerifyAIScanner({
           style={styles.camera}
           facing="back"
           enableTorch={shouldEnableTorch}
-          onCameraReady={onCameraReady}
+          onCameraReady={() => onCameraReady(renderedCameraGeneration)}
           onMountError={onMountError}
           responsiveOrientationWhenOrientationLocked
           onResponsiveOrientationChanged={(event) => {

package/src/components/cameraCaptureRetry.ts

@@ -1,4 +1,5 @@
 export const CAMERA_CAPTURE_RETRY_DELAY_MS = 350;
+export const CAMERA_CAPTURE_RETRY_POST_READY_MS = 350;
 export const CAMERA_CAPTURE_RETRY_TORCH_SETTLE_MS = 800;
 export const IOS_CAMERA_CAPTURE_RETRY_READY_TIMEOUT_MS = 3000;
 export const ANDROID_CAMERA_CAPTURE_RETRY_READY_TIMEOUT_MS = 10000;
@@ -12,6 +13,40 @@ export interface CameraCaptureRetryPlan {
   suppressTorch: boolean;
 }
 
+export interface CameraCaptureRetryState<T> {
+  camera: T | null;
+  generation: number;
+  ready: boolean;
+  active: boolean;
+}
+
+/** Wait for a fresh camera, preserving the existing total-delay/deadline policy. */
+export async function waitForCameraCaptureRetry<T>(
+  readState: () => CameraCaptureRetryState<T>,
+  previousCamera: T | null,
+  generation: number,
+  requestedAt: number,
+  plan: CameraCaptureRetryPlan,
+  sleep: (ms: number) => Promise<void> = ms => new Promise(resolve => setTimeout(resolve, ms)),
+  now: () => number = Date.now,
+): Promise<T | null> {
+  // Previously readiness polling began only after the total settle delay.
+  const deadline = requestedAt + plan.settleDelayMs + plan.readyTimeoutMs;
+  let state = readState();
+  while (state.active && state.generation === generation &&
+         !(state.ready && state.camera && state.camera !== previousCamera)) {
+    if (now() >= deadline) return null;
+    await sleep(Math.min(100, deadline - now()));
+    state = readState();
+  }
+  if (!state.active || state.generation !== generation || !state.ready || !state.camera) return null;
+  const camera = state.camera;
+  const captureAt = Math.max(requestedAt + plan.settleDelayMs, now() + CAMERA_CAPTURE_RETRY_POST_READY_MS);
+  await sleep(Math.max(0, captureAt - now()));
+  state = readState();
+  return state.active && state.generation === generation && state.ready && state.camera === camera ? camera : null;
+}
+
 export function getCameraCaptureRetryPlan(
   platform: CameraCaptureRetryPlatform,
   torchRequested: boolean,

package/src/version.ts

@@ -1 +1 @@
-export const SDK_VERSION = '2.5.6';
+export const SDK_VERSION = '2.5.8';