@smileid/usesmileid 12.0.0 → 12.0.1

package/src/presentation/screen/helpers/capture_ui_state.ts

@@ -1,8 +1,8 @@
 import type {
   ScanHeadTurnDirection,
-  ScanState,
+  UseSmileIDScanState,
 } from "@smileid/usesmileid_bridge";
-import { ScanStateType } from "@smileid/usesmileid_bridge";
+import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
 import { CaptureType } from "../../../core/models/ml_config";
 import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
 import type { SiKey } from "../../../l10n/strings_en";
@@ -12,7 +12,7 @@ import {
   selfieFeedbackKeyFor,
 } from "./capture_screen_helpers";
 
-/** Immutable per-frame UI snapshot derived from the native `ScanState`. */
+/** Immutable per-frame UI snapshot derived from the native `UseSmileIDScanState`. */
 export type UseSmileIDCaptureUiState = {
   readonly overlayState: UseSmileIDOverlayState;
   /** Stable si_* key behind the guidance copy and the coaching-animation lookup. */
@@ -128,21 +128,21 @@ export function preCaptureUiState(
  * `unsatisfied`, or `timeout`/`finished` returning to `initial`.
  */
 export function isSessionBoundary(
-  previous: ScanState,
-  next: ScanState,
+  previous: UseSmileIDScanState,
+  next: UseSmileIDScanState,
 ): boolean {
   if (previous.type === next.type) return false;
-  if (previous.type === ScanStateType.Unsatisfied) return true;
+  if (previous.type === UseSmileIDScanStateType.Unsatisfied) return true;
   return (
-    (previous.type === ScanStateType.Timeout ||
-      previous.type === ScanStateType.Finished) &&
-    next.type === ScanStateType.Initial
+    (previous.type === UseSmileIDScanStateType.Timeout ||
+      previous.type === UseSmileIDScanStateType.Finished) &&
+    next.type === UseSmileIDScanStateType.Initial
   );
 }
 
 /** Dispatch on capture type — see {@link mapSelfieUiState} / {@link mapDocumentUiState}. */
 export function mapCaptureUiState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
   captureType: CaptureType,
   enableEnhancedLiveness: boolean,
 ): UseSmileIDCaptureUiState {
@@ -157,7 +157,7 @@ export function mapCaptureUiState(
  * still…") and zeroes the fill.
  */
 export function mapSelfieUiState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
   enableEnhancedLiveness: boolean,
 ): UseSmileIDCaptureUiState {
   return withEnhancedLivenessPolicy(
@@ -167,11 +167,11 @@ export function mapSelfieUiState(
 }
 
 function selfieUiState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
   enableEnhancedLiveness: boolean,
 ): UseSmileIDCaptureUiState {
   switch (scanState.type) {
-    case ScanStateType.Initial:
+    case UseSmileIDScanStateType.Initial:
       return uiState(
         UseSmileIDOverlayState.INSTRUCTION,
         enableEnhancedLiveness
@@ -180,7 +180,7 @@ function selfieUiState(
         0,
       );
 
-    case ScanStateType.Found: {
+    case UseSmileIDScanStateType.Found: {
       const overlayState = mapScanStateToOverlayState(
         scanState,
         CaptureType.selfie,
@@ -191,7 +191,7 @@ function selfieUiState(
       return uiState(overlayState, feedbackKey, scanState.captureProgress ?? 0);
     }
 
-    case ScanStateType.Satisfied:
+    case UseSmileIDScanStateType.Satisfied:
       // Progress forced to 1 so the ring completes even when the last
       // interim frame undershot; transient before `finished`.
       return uiState(
@@ -200,7 +200,7 @@ function selfieUiState(
         1,
       );
 
-    case ScanStateType.Unsatisfied:
+    case UseSmileIDScanStateType.Unsatisfied:
       // Unsatisfied collapses onto one requirements-not-met copy —
       // the per-check `reason` only feeds telemetry, not guidance.
       return uiState(
@@ -209,13 +209,13 @@ function selfieUiState(
         0,
       );
 
-    case ScanStateType.Finished:
+    case UseSmileIDScanStateType.Finished:
       return scannedUiState(enableEnhancedLiveness);
 
-    case ScanStateType.Timeout:
+    case UseSmileIDScanStateType.Timeout:
       return uiState(UseSmileIDOverlayState.IDLE, "si_capture_timeout", 0);
 
-    case ScanStateType.HeadTurn: {
+    case UseSmileIDScanStateType.HeadTurn: {
       const direction = scanState.currentDirection ?? null;
       const turnPrompt: SiKey =
         direction === "left"
@@ -243,20 +243,20 @@ function selfieUiState(
 
 /** Document scan-state → UI-state mapping. */
 export function mapDocumentUiState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
 ): UseSmileIDCaptureUiState {
   switch (scanState.type) {
-    case ScanStateType.Initial:
+    case UseSmileIDScanStateType.Initial:
     // No head-turn phase for documents; a degenerate headTurn maps to
     // the pre-capture instruction.
-    case ScanStateType.HeadTurn:
+    case UseSmileIDScanStateType.HeadTurn:
       return uiState(
         UseSmileIDOverlayState.INSTRUCTION,
         "si_document_initial_instruction",
         0,
       );
 
-    case ScanStateType.Found: {
+    case UseSmileIDScanStateType.Found: {
       const overlayState = mapScanStateToOverlayState(
         scanState,
         CaptureType.document,
@@ -275,20 +275,20 @@ export function mapDocumentUiState(
 
     // Documents collapse satisfied/finished onto the same terminal
     // snapshot: the still is captured and the screen is moving on.
-    case ScanStateType.Satisfied:
+    case UseSmileIDScanStateType.Satisfied:
       return scannedDocumentUiState();
 
-    case ScanStateType.Unsatisfied:
+    case UseSmileIDScanStateType.Unsatisfied:
       return uiState(
         UseSmileIDOverlayState.IDLE,
         "si_document_capture_unsatisfied",
         0,
       );
 
-    case ScanStateType.Finished:
+    case UseSmileIDScanStateType.Finished:
       return scannedDocumentUiState();
 
-    case ScanStateType.Timeout:
+    case UseSmileIDScanStateType.Timeout:
       return uiState(
         UseSmileIDOverlayState.IDLE,
         "si_document_capture_timeout",

package/src/presentation/screen/helpers/ess_turn_haptics.ts

@@ -1,6 +1,6 @@
 import * as Haptics from "expo-haptics";
-import type { ScanState } from "@smileid/usesmileid_bridge";
-import { ScanStateType } from "@smileid/usesmileid_bridge";
+import type { UseSmileIDScanState } from "@smileid/usesmileid_bridge";
+import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
 
 /** Which haptic a completed Enhanced Smart Selfie head turn warrants. */
 export type EssTurnHaptic = "intermediate" | "final";
@@ -20,16 +20,16 @@ export type EssTurnHaptic = "intermediate" | "final";
  * scan state so the same completion is reported exactly once.
  */
 export function essTurnHaptic(
-  previous: ScanState,
-  next: ScanState,
+  previous: UseSmileIDScanState,
+  next: UseSmileIDScanState,
 ): EssTurnHaptic | null {
   // Only a transition out of an active, directed head turn can complete one.
-  if (previous.type !== ScanStateType.HeadTurn) return null;
+  if (previous.type !== UseSmileIDScanStateType.HeadTurn) return null;
   if (previous.currentDirection === undefined) return null;
 
   // The requested direction advanced — the previous turn completed.
   if (
-    next.type === ScanStateType.HeadTurn &&
+    next.type === UseSmileIDScanStateType.HeadTurn &&
     next.currentDirection !== undefined &&
     next.currentDirection !== previous.currentDirection
   ) {
@@ -39,9 +39,9 @@ export function essTurnHaptic(
   // Leaving the head-turn phase toward capture is the final turn's
   // completion; `initial` / `timeout` are resets, not completions.
   if (
-    next.type === ScanStateType.Found ||
-    next.type === ScanStateType.Satisfied ||
-    next.type === ScanStateType.Finished
+    next.type === UseSmileIDScanStateType.Found ||
+    next.type === UseSmileIDScanStateType.Satisfied ||
+    next.type === UseSmileIDScanStateType.Finished
   ) {
     return "final";
   }

package/src/presentation/screen/helpers/scan_state_to_overlay_state.ts

@@ -1,16 +1,16 @@
-import type { ScanState } from "@smileid/usesmileid_bridge";
-import { ScanStateType } from "@smileid/usesmileid_bridge";
+import type { UseSmileIDScanState } from "@smileid/usesmileid_bridge";
+import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
 import { CaptureType } from "../../../core/models/ml_config";
 import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
 
 /**
- * Map an analyzer's `ScanState` into the SDK's visual `OverlayState`.
+ * Map an analyzer's `UseSmileIDScanState` into the SDK's visual `OverlayState`.
  *
  * The overlay enum drives the face/document oval's border colour, dash
  * pattern, and fill animation — it's a presentation concept layered on
  * top of the scan-state machine. The mapping reads `state.feedback`
- * (when `type === ScanStateType.Found`) and `state.reason` (when
- * `type === ScanStateType.Unsatisfied`) to pick the fine-grained
+ * (when `type === UseSmileIDScanStateType.Found`) and `state.reason` (when
+ * `type === UseSmileIDScanStateType.Unsatisfied`) to pick the fine-grained
  * overlay state; other scan-state types map coarsely to the matching
  * lifecycle entry.
  *
@@ -20,14 +20,14 @@ import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
  * a new feedback key the JS side hasn't been updated for.
  */
 export function mapScanStateToOverlayState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
   captureType: CaptureType,
 ): UseSmileIDOverlayState {
   switch (scanState.type) {
-    case ScanStateType.Initial:
+    case UseSmileIDScanStateType.Initial:
       return UseSmileIDOverlayState.INSTRUCTION;
 
-    case ScanStateType.Found:
+    case UseSmileIDScanStateType.Found:
       // `feedback` is the canonical `si_capture_*` key the native side
       // emits; partner code never sees raw English copy.
       return resolveFeedbackOverlay(
@@ -38,10 +38,10 @@ export function mapScanStateToOverlayState(
           : UseSmileIDOverlayState.DOCUMENT_READY,
       );
 
-    case ScanStateType.Satisfied:
+    case UseSmileIDScanStateType.Satisfied:
       return UseSmileIDOverlayState.READY;
 
-    case ScanStateType.Unsatisfied:
+    case UseSmileIDScanStateType.Unsatisfied:
       return resolveFeedbackOverlay(
         scanState.reason,
         captureType,
@@ -50,13 +50,13 @@ export function mapScanStateToOverlayState(
           : UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED,
       );
 
-    case ScanStateType.Finished:
+    case UseSmileIDScanStateType.Finished:
       return UseSmileIDOverlayState.CAPTURING;
 
-    case ScanStateType.HeadTurn:
+    case UseSmileIDScanStateType.HeadTurn:
       return UseSmileIDOverlayState.HEAD_TURN;
 
-    case ScanStateType.Timeout:
+    case UseSmileIDScanStateType.Timeout:
       // Back to the gray pre-capture state while partners re-prompt.
       return UseSmileIDOverlayState.IDLE;
   }

package/src/presentation/screen/helpers/use_capture_orientation_lock.ts

@@ -3,6 +3,14 @@ import * as ScreenOrientation from "expo-screen-orientation";
 import { UseSmileIDCrashReporting } from "@smileid/usesmileid_bridge";
 import type { DocumentOrientation } from "../../../core/models/document_type";
 
+export type CaptureOrientationOptions = {
+  /**
+   * Lock applied when the capture screen unmounts. Defaults to portrait-up;
+   * threaded from the builder's `exitOrientations`.
+   */
+  readonly exitLock?: ScreenOrientation.OrientationLock;
+};
+
 /**
  * Lock device orientation for a capture screen, scoped to its lifetime
  * (`"Landscape"` → landscape, `"Portrait"` → portrait-up).
@@ -10,26 +18,76 @@ import type { DocumentOrientation } from "../../../core/models/document_type";
  * Each screen asserts its OWN orientation on mount, so document → selfie
  * reverts deterministically rather than depending on the previous
  * screen's teardown winning a race against the next camera initialising.
- * Unmount restores portrait-up as a safety net.
  *
  * Locks are global: the host app must permit the locked orientations at
  * the OS level (iOS `UISupportedInterfaceOrientations`, Android activity
- * `screenOrientation`) for the lock to take effect.
+ * `screenOrientation`) for the lock to take effect — a host that does not
+ * is warned about and reported rather than silently staying upright.
  */
 export function useCaptureOrientationLock(
   orientation: DocumentOrientation,
+  {
+    exitLock = ScreenOrientation.OrientationLock.PORTRAIT_UP,
+  }: CaptureOrientationOptions = {},
 ): void {
   useEffect(() => {
     const target =
       orientation === "Landscape"
         ? ScreenOrientation.OrientationLock.LANDSCAPE
         : ScreenOrientation.OrientationLock.PORTRAIT_UP;
+    void reportIfLockUnsupported(target);
     void lockOrientation(target);
 
     return () => {
-      void lockOrientation(ScreenOrientation.OrientationLock.PORTRAIT_UP);
+      void lockOrientation(exitLock);
     };
-  }, [orientation]);
+  }, [orientation, exitLock]);
+}
+
+/**
+ * Surface a host build that cannot honour `target`. `lockAsync` resolves
+ * successfully in that case, so without this preflight the capture screen
+ * just stays in the wrong orientation with no signal. (Expo's `app.json`
+ * `orientation` value is not such a case: the module's app-delegate hook
+ * outranks the baked `Info.plist` on iOS — device-verified.)
+ */
+async function reportIfLockUnsupported(
+  target: ScreenOrientation.OrientationLock,
+): Promise<void> {
+  let supported: boolean;
+  try {
+    supported = await ScreenOrientation.supportsOrientationLockAsync(target);
+  } catch (error) {
+    reportOrientationFailure(error);
+    return;
+  }
+  if (supported) return;
+
+  // `typeof` guard: `__DEV__` is bundler-injected and absent outside Metro-like
+  // environments, where a bare reference throws rather than reading falsy.
+  const isDevBuild = typeof __DEV__ !== "undefined" && __DEV__;
+  if (isDevBuild && !warnedUnsupportedTargets.has(target)) {
+    warnedUnsupportedTargets.add(target);
+    console.warn(
+      "[UseSmileID] The capture screen needs to lock the device orientation, " +
+        "but this build does not permit it. Allow the required orientations " +
+        "in your app's iOS Info.plist / Android manifest.",
+    );
+  }
+  reportOrientationFailure(
+    new Error(`orientation lock unsupported by host build: ${target}`),
+  );
+}
+
+/**
+ * Dedupes the dev warning per target: a flow remounts the capture screen for the back
+ * side and interstitial, and the misconfiguration can't change mid-session.
+ */
+const warnedUnsupportedTargets = new Set<ScreenOrientation.OrientationLock>();
+
+/** Test seam: clears the once-per-target dev-warning dedupe. */
+export function resetUnsupportedLockWarningsForTesting(): void {
+  warnedUnsupportedTargets.clear();
 }
 
 /** Lock to `target`, routing a native failure through crash reporting. */
@@ -39,8 +97,12 @@ async function lockOrientation(
   try {
     await ScreenOrientation.lockAsync(target);
   } catch (error) {
-    UseSmileIDCrashReporting.captureException(
-      error instanceof Error ? error : new Error(String(error)),
-    );
+    reportOrientationFailure(error);
   }
 }
+
+function reportOrientationFailure(error: unknown): void {
+  UseSmileIDCrashReporting.captureException(
+    error instanceof Error ? error : new Error(String(error)),
+  );
+}

package/src/presentation/screen/use_smile_id_capture_screen.tsx

@@ -28,11 +28,14 @@ import type {
   DocumentAnalyzer,
   FaceAnalyzer,
 } from "@smileid/usesmileid_platform_interface";
-import type { CaptureReadyEvent, ScanState } from "@smileid/usesmileid_bridge";
+import type {
+  CaptureReadyEvent,
+  UseSmileIDScanState,
+} from "@smileid/usesmileid_bridge";
 import {
   CaptureReadyEventKind,
   DocumentSide,
-  ScanStateType,
+  UseSmileIDScanStateType,
 } from "@smileid/usesmileid_bridge";
 import { CaptureType } from "../../core/models/ml_config";
 import type { DocumentCaptureMode } from "../../core/models/document_capture_mode";
@@ -108,7 +111,7 @@ export type UseSmileIDCaptureScreenProps = {
   readonly onDocumentOrigin?: (origin: DocumentImageOrigin) => void;
 
   /** Fires when the state machine reaches `"timeout"`; the screen stops streaming. */
-  readonly onCaptureTimeout?: (state: ScanState) => void;
+  readonly onCaptureTimeout?: (state: UseSmileIDScanState) => void;
 
   readonly onBack?: () => void;
   readonly showAttribution?: boolean;
@@ -116,6 +119,9 @@ export type UseSmileIDCaptureScreenProps = {
   /** Keeps the oval rim neutral through CAPTURING/PROCESSING — ESS has no green oval treatment. */
   readonly enableEnhancedLiveness?: boolean;
 
+  /** Runs a selfie capture on the rear camera. Ignored for document capture. */
+  readonly allowAgentMode?: boolean;
+
   /**
    * Document aspect ratio (width / height) for the document capture
    * guide cutout. Ignored for selfie capture. Omitted ⇒ the overlay's
@@ -162,9 +168,12 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
   const theme = props.theme ?? defaultLightTheme;
   const showAttribution = props.showAttribution ?? true;
   const enableEnhancedLiveness = props.enableEnhancedLiveness ?? false;
+  const allowAgentMode = props.allowAgentMode ?? false;
   // Literal union — useCameraDevice takes the lowercase string directly.
   const cameraFacing: "front" | "back" =
-    props.captureType === CaptureType.selfie ? "front" : "back";
+    props.captureType === CaptureType.selfie && !allowAgentMode
+      ? "front"
+      : "back";
 
   const { hasPermission, requestPermission } = useCameraPermission();
   const device = useCameraDevice(cameraFacing);
@@ -202,8 +211,8 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
   }, [hasPermission, requestPermission]);
 
   // Per-frame scan state drives the overlay + feedback bubble.
-  const [scanState, setScanState] = useState<ScanState>({
-    type: ScanStateType.Initial,
+  const [scanState, setScanState] = useState<UseSmileIDScanState>({
+    type: UseSmileIDScanStateType.Initial,
   });
   const [streaming, setStreaming] = useState<boolean>(false);
   // Bumped on every Start tap to reset the feedback debouncer.
@@ -213,6 +222,11 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
   const [hasAnalyzedFrame, setHasAnalyzedFrame] = useState<boolean>(false);
   // Fallback shutter, revealed after activateManualAfterMs. Resets per mount.
   const [manualShutterRevealed, setManualShutterRevealed] = useState(false);
+  // Set when a document scan times out, so the recovery controls stay on screen
+  // after the scan (and `streaming`) stops. `timedOutRef` keeps the terminal
+  // branch idempotent without latching the one-shot delivery gate.
+  const [captureTimedOut, setCaptureTimedOut] = useState(false);
+  const timedOutRef = useRef(false);
   // True while a manual/gallery delivery is in flight — disables the controls.
   const [deliveringDocument, setDeliveringDocument] = useState(false);
   // Transient gallery-import error; overrides the live chip, self-clears so the user can re-pick.
@@ -232,7 +246,7 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
   const completedRef = useRef<boolean>(false);
   // Raw (not committed) frame state for the session-boundary check, so
   // transitions the 1% bucketing skips committing are still seen.
-  const previousScanStateRef = useRef<ScanState | null>(null);
+  const previousScanStateRef = useRef<UseSmileIDScanState | null>(null);
 
   // Capture telemetry: wall-clock start (first analyzed frame) and a
   // rising-edge `unsatisfied` retry counter, surfaced via onCaptureComplete.
@@ -475,13 +489,14 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
       if (captureStartedAtRef.current === null) {
         captureStartedAtRef.current = Date.now();
       }
-      const isUnsatisfied = result.state.type === ScanStateType.Unsatisfied;
+      const isUnsatisfied =
+        result.state.type === UseSmileIDScanStateType.Unsatisfied;
       if (isUnsatisfied && !wasUnsatisfiedRef.current) {
         captureRetriesRef.current += 1;
       }
       wasUnsatisfiedRef.current = isUnsatisfied;
 
-      if (result.state.type === ScanStateType.Unsatisfied) {
+      if (result.state.type === UseSmileIDScanStateType.Unsatisfied) {
         capturedEventsRef.current = [];
       } else if (result.capturedEvents.length > 0) {
         capturedEventsRef.current = [
@@ -507,7 +522,7 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
 
       // Terminal states: finished → flush + complete; timeout → failure
       // without flushing (no captured artifacts to wait on).
-      if (result.state.type === ScanStateType.Finished) {
+      if (result.state.type === UseSmileIDScanStateType.Finished) {
         if (completedRef.current) return;
         completedRef.current = true;
         setStreaming(false);
@@ -524,10 +539,18 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
             onDocumentOrigin?.(DocumentImageOrigin.CameraAutoCapture);
             onCaptureComplete?.(capturedEventsRef.current, captureTelemetry());
           });
-      } else if (result.state.type === ScanStateType.Timeout) {
-        if (completedRef.current) return;
-        completedRef.current = true;
+      } else if (result.state.type === UseSmileIDScanStateType.Timeout) {
+        if (completedRef.current || timedOutRef.current) return;
         setStreaming(false);
+        if (isDocumentCapture) {
+          // Document capture has no Start button, so a timeout must leave a way
+          // forward: reveal the manual shutter and keep the delivery gate open
+          // so the tap can still produce a capture.
+          timedOutRef.current = true;
+          setCaptureTimedOut(true);
+        } else {
+          completedRef.current = true;
+        }
         onCaptureTimeout?.(result.state);
       }
     },
@@ -549,7 +572,7 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
     sessionEpoch,
   );
   const isInstructionState =
-    scanState.type === ScanStateType.Initial && !streaming;
+    scanState.type === UseSmileIDScanStateType.Initial && !streaming;
   const canStart = !streaming && !completedRef.current;
 
   const previewReady = hasPermission && device != null;
@@ -687,13 +710,18 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
   // Document controls — live capture only (after Start). Manual shutter
   // follows the capture mode + fallback timer; gallery follows
   // allowGalleryUpload. Renderer also hides both during CAPTURING/PROCESSING.
+  // A timeout offers the shutter in every capture mode — it is the recovery
+  // affordance, so it outranks `captureMode` and survives `streaming` going
+  // false with the scan.
   const manualShutterAvailable =
     isDocumentCapture &&
-    streaming &&
-    (captureMode?.kind === "manualCapture" ||
-      (captureMode?.kind === "autoCaptureWithManualFallback" &&
-        manualShutterRevealed));
-  const galleryAvailable = isDocumentCapture && streaming && allowGalleryUpload;
+    (captureTimedOut ||
+      (streaming &&
+        (captureMode?.kind === "manualCapture" ||
+          (captureMode?.kind === "autoCaptureWithManualFallback" &&
+            manualShutterRevealed))));
+  const galleryAvailable =
+    isDocumentCapture && (streaming || captureTimedOut) && allowGalleryUpload;
 
   // Deps are scalar fields (mapCaptureUiState returns a fresh object per
   // render). captureProgress intentionally stays a separate per-frame prop.

package/src/presentation/screen/use_smile_id_consent_screen.tsx

@@ -26,6 +26,7 @@ import { UseSmileIDLearnMoreContent } from "../components/use_smile_id_learn_mor
 import { UseSmileIDPartnerIcon } from "../components/use_smile_id_partner_icon";
 import { UseSmileIDRoundedCheckbox } from "../components/use_smile_id_rounded_checkbox";
 import { useUseSmileIDLocalizations } from "../../l10n/use_smile_id_localizations_provider";
+import { GlobalPrivacyControl } from "../../core/models/global_privacy_control";
 import { getDefaultConsentState, getDeviceLocale } from "../utils/locale_utils";
 import {
   buildConsentRows,
@@ -59,6 +60,12 @@ export type UseSmileIDConsentScreenProps = {
   readonly showAttribution?: boolean;
   readonly onAllow?: (info: ConsentInformation) => void;
   readonly onDeny?: () => void;
+  /**
+   * Partner-declared consent posture; seeds the checkbox's initial state
+   * via `getDefaultConsentState`. Defaults to the universal opt-out
+   * baseline (`GlobalPrivacyControl.OptOut`).
+   */
+  readonly globalPrivacyControl?: GlobalPrivacyControl;
   readonly theme?: UseSmileIDTheme;
   /**
    * Render the bottom-pinned Allow button via a partner-supplied
@@ -107,11 +114,15 @@ export function UseSmileIDConsentScreen(props: UseSmileIDConsentScreenProps) {
   const loc = useUseSmileIDLocalizations();
   const showAttribution = props.showAttribution ?? true;
 
-  // Locale-aware default: ticked outside the EU (`true`), unticked
-  // inside (`false`) to honour GDPR opt-in. `getDefaultConsentState()`
-  // reads the resolved BCP-47 locale and checks the country segment
-  // against the EU member-state set.
-  const [consented, setConsented] = useState(() => getDefaultConsentState());
+  const globalPrivacyControl =
+    props.globalPrivacyControl ?? GlobalPrivacyControl.OptOut;
+
+  // Posture-aware default: the opt-out baseline starts ticked everywhere;
+  // the legacy opt-in posture consults the resolved BCP-47 locale and
+  // starts unticked for EU member states (GDPR opt-in).
+  const [consented, setConsented] = useState(() =>
+    getDefaultConsentState(globalPrivacyControl),
+  );
   const [learnMoreOpen, setLearnMoreOpen] = useState(false);
 
   const subtitleParts = composeConsentSubtitleParts(props.partnerName, loc);

package/src/presentation/screen/use_smile_id_document_back_instructions.tsx

@@ -1,7 +1,8 @@
-import { Pressable, StyleSheet, Text, View } from "react-native";
+import { StyleSheet, Text, View } from "react-native";
 import { SafeAreaView } from "react-native-safe-area-context";
 import type { UseSmileIDTheme } from "../theme/theme";
 import { useUseSmileIDTheme } from "../theme/theme_context";
+import { UseSmileIDAttribution } from "../components/use_smile_id_attribution";
 import { UseSmileIDBackButton } from "../components/use_smile_id_back_button";
 import { UseSmileIDButton } from "../components/use_smile_id_button";
 import { UseSmileIDInstructionsHero } from "../components/use_smile_id_instructions_hero";
@@ -48,7 +49,7 @@ export function UseSmileIDDocumentBackInstructions(
         styles.root,
         {
           backgroundColor: theme.colors.background,
-          paddingHorizontal: theme.spacing.large,
+          paddingHorizontal: theme.spacing.medium,
           paddingVertical: theme.spacing.medium,
         },
       ]}
@@ -70,12 +71,15 @@ export function UseSmileIDDocumentBackInstructions(
           ...theme.typography.pageHeading,
           fontWeight: "800",
           color: theme.colors.titleText,
+          textAlign: "center",
         }}
         testID="si_document_back_instructions_title"
       >
         {localizations.siDocumentFlipTitle(props.documentTypeDisplayName)}
       </Text>
 
+      <View style={{ height: theme.spacing.medium }} />
+
       <View style={styles.hero} testID="si_document_back_instructions_hero">
         <UseSmileIDInstructionsHero
           source={heroSource}
@@ -98,24 +102,17 @@ export function UseSmileIDDocumentBackInstructions(
         {allowSkip ? (
           <>
             <View style={{ height: theme.spacing.small }} />
-            <Pressable
-              onPress={onSkip}
-              accessibilityRole="button"
+            <UseSmileIDButton
+              label={localizations.siDocumentSkipBack}
+              onClick={onSkip}
+              variant="secondary"
+              theme={theme}
               testID="si_document_skip_back_button"
-              style={styles.skip}
-            >
-              <Text
-                style={{
-                  ...theme.typography.button,
-                  color: theme.colors.primary,
-                  textAlign: "center",
-                }}
-              >
-                {localizations.siDocumentSkipBack}
-              </Text>
-            </Pressable>
+            />
           </>
         ) : null}
+        <View style={{ height: theme.spacing.small }} />
+        <UseSmileIDAttribution theme={theme} />
       </View>
     </SafeAreaView>
   );
@@ -125,10 +122,4 @@ const styles = StyleSheet.create({
   root: { flex: 1 },
   hero: { flex: 1 },
   bottom: { alignItems: "center" },
-  skip: {
-    height: 48,
-    alignItems: "center",
-    justifyContent: "center",
-    alignSelf: "stretch",
-  },
 });