@smileid/usesmileid 12.0.0-beta01 → 12.0.0

package/src/presentation/flow/flow_navigation_manager.ts

@@ -15,7 +15,10 @@ import type {
 } from "../../core/models/params";
 import { JobType } from "../../core/models/job_type";
 import { CaptureType } from "../../core/models/ml_config";
-import type { DocumentType } from "../../core/models/document_type";
+import {
+  defaultFrameAspectRatio,
+  type DocumentType,
+} from "../../core/models/document_type";
 import type { JobSubmissionResponse } from "../../data/model/job_submission_response";
 import { MissingRequiredFieldException } from "../../core/exception/job_validation_exceptions";
 import {
@@ -37,9 +40,18 @@ import {
   DOCUMENT_FRONT_IMAGE_ORIGIN_KEY,
   type DocumentImageOrigin,
 } from "../../metadata/document_image_origin";
+import { configurationMetadataEntries } from "../../metadata/metadata_configuration_mappers";
+import {
+  CAPTURE_IMAGE_COLOR_DEPTH,
+  CAPTURE_IMAGE_PIXEL_CONFIG,
+} from "../../metadata/captured_image_properties";
+import type { CaptureTelemetry } from "../screen/use_smile_id_capture_screen";
 import type { SdkConfig } from "../../data/model/sdk_config";
 import { numSamplesOverride } from "../../data/model/sdk_config";
-import { decodeSmileIDToken } from "../../data/util/use_smile_id_token_decoder";
+import {
+  decodeSmileIDToken,
+  type DecodedToken,
+} from "../../data/util/use_smile_id_token_decoder";
 import {
   DocumentSide,
   EnhancedSmartSelfieConfig,
@@ -123,6 +135,17 @@ export class FlowNavigationManager {
     DocumentSide,
     DocumentImageOrigin
   >();
+  // Capture telemetry recorded at capture completion (selfie + per document side).
+  private _selfieCaptureTelemetry: CaptureTelemetry | undefined;
+  private readonly _documentCaptureTelemetry = new Map<
+    DocumentSide,
+    CaptureTelemetry
+  >();
+  // Identifier of the camera used for the most recent capture.
+  private _cameraName: string | undefined;
+  // Accelerometer telemetry from the most recent capture (device_positions / movement).
+  private _devicePositions: readonly string[] = [];
+  private _deviceMovementDetected: number | null = null;
   private _jobSubmissionState: JobSubmissionState = { kind: "notAttempted" };
   private readonly _listeners = new Set<Listener>();
   private readonly _steps: readonly ScreenSpec[];
@@ -140,6 +163,23 @@ export class FlowNavigationManager {
    */
   readonly resolvedSdkConfig: SdkConfig | undefined;
 
+  /** Canonical `partner_id` decoded from the JWT (raw); resolved via the [partnerId] getter. */
+  private readonly _resolvedPartnerId: string | undefined;
+
+  /**
+   * Partner identifier the capture screen stamps into the Smile EXIF tag — the tag's HMAC/AES
+   * keys derive from it and the backend validates the tag against the request's partner_id.
+   *
+   * Sourced from the JWT `partner_id` claim (server-canonical form, e.g. `"002"`) so the stamped
+   * value matches what the backend keys on; falls back to the partner-supplied config value when
+   * the claim is absent/blank. Empty = skip tagging.
+   */
+  get partnerId(): string {
+    const jwtPartnerId = this._resolvedPartnerId;
+    if (jwtPartnerId && jwtPartnerId.length > 0) return jwtPartnerId;
+    return this._configuration.network?.config?.partnerConfig?.partnerId ?? "";
+  }
+
   /** Stable per-flow session id, stamped into every analytics event's `session_id`. */
   private readonly _sessionId: string;
 
@@ -157,9 +197,11 @@ export class FlowNavigationManager {
     this._metadataProvider =
       options.metadataProvider ?? new UseSmileIDMetadataFactory();
     this._sessionId = this._metadataProvider.sessionId;
-    this.resolvedSdkConfig = FlowNavigationManager._decodeSdkConfig(
+    const decodedToken = FlowNavigationManager._decodeToken(
       options.configuration,
     );
+    this.resolvedSdkConfig = decodedToken?.sdkConfig;
+    this._resolvedPartnerId = decodedToken?.partnerId;
     // Seed the path with the first screen so currentScreen/renderer have a
     // deterministic start. Empty path → host renders the "no screens"
     // sentinel (validation rejects empty screens at build time anyway).
@@ -204,6 +246,29 @@ export class FlowNavigationManager {
     return undefined;
   }
 
+  /**
+   * Resolved document capture-frame aspect ratio (width / height), shared by
+   * capture, preview, and processing. Precedence: type `knownAspectRatio` →
+   * partner `knownIdAspectRatio` → orientation default.
+   */
+  get documentFrameAspectRatio(): number | undefined {
+    for (const step of this._steps) {
+      if (
+        step.kind === "capture" &&
+        step.config.captureType === CaptureType.document
+      ) {
+        const documentConfig = step.config.documentConfig;
+        return (
+          documentConfig?.resolvedAspectRatio ??
+          defaultFrameAspectRatio(
+            documentConfig?.documentType?.orientation ?? "Landscape",
+          )
+        );
+      }
+    }
+    return undefined;
+  }
+
   // --- navigation path --------------------------------------------------
 
   /** Read-only navigation stack; top is the active screen. */
@@ -265,6 +330,23 @@ export class FlowNavigationManager {
       if (next?.kind === "preview") return this._steps[currentIdx + 2];
     }
 
+    // At the document capture step with the front captured, the back still
+    // pending, and no document preview to drive the per-side loop, re-enter the
+    // capture step for the back side so captureBothSides is honoured even when
+    // the flow omits the document preview { } step. When a preview does follow,
+    // the per-side loop above handles the back instead.
+    if (
+      current.kind === "capture" &&
+      current.config.captureType === CaptureType.document &&
+      this.documentCapturesBack() &&
+      this._captured.frontDocumentPath !== undefined &&
+      this._captured.backDocumentPath === undefined &&
+      !this._documentBackSkipped &&
+      !this.documentPreviewFollowsCapture()
+    ) {
+      return current;
+    }
+
     return this._steps[currentIdx + 1];
   }
 
@@ -485,6 +567,31 @@ export class FlowNavigationManager {
     this._documentImageOrigins.set(side, origin);
   }
 
+  /** Records selfie capture telemetry (duration + retries) at capture completion. */
+  recordSelfieCaptureTelemetry(telemetry: CaptureTelemetry): void {
+    if (this._disposed) return;
+    this._selfieCaptureTelemetry = telemetry;
+    this._captureCameraName(telemetry);
+  }
+
+  /** Records per-side document capture telemetry at each side's completion. */
+  recordDocumentCaptureTelemetry(
+    side: DocumentSide,
+    telemetry: CaptureTelemetry,
+  ): void {
+    if (this._disposed) return;
+    this._documentCaptureTelemetry.set(side, telemetry);
+    this._captureCameraName(telemetry);
+  }
+
+  private _captureCameraName(telemetry: CaptureTelemetry): void {
+    if (telemetry.cameraName) this._cameraName = telemetry.cameraName;
+    if (telemetry.devicePositions.length > 0) {
+      this._devicePositions = telemetry.devicePositions;
+      this._deviceMovementDetected = telemetry.deviceMovementDetected;
+    }
+  }
+
   /** Per-side document origin wire entries (front then back; omitted when unset). */
   private _documentImageOriginEntries(): MetadataEntry[] {
     const entries: MetadataEntry[] = [];
@@ -499,6 +606,60 @@ export class FlowNavigationManager {
     return entries;
   }
 
+  /**
+   * Capture telemetry + image-property wire entries. Durations and retries keep
+   * a meaningful 0 (capture ran) and are omitted only when that capture type
+   * never ran. Color depth / pixel config are emitted for each present capture;
+   * document sizes when measured.
+   */
+  private _captureTelemetryEntries(): MetadataEntry[] {
+    const entries: MetadataEntry[] = [];
+    const push = (name: string, value: string) => entries.push({ name, value });
+
+    const selfie = this._selfieCaptureTelemetry;
+    if (selfie) {
+      // Duration + retries keep a meaningful 0 (capture ran); telemetry is absent only when the
+      // capture type never ran.
+      push("selfie_capture_duration_ms", String(selfie.durationMs));
+      push("selfie_capture_retries", String(selfie.retries));
+    }
+    if (this._captured.selfiePath !== undefined) {
+      push("selfie_image_color_depth", String(CAPTURE_IMAGE_COLOR_DEPTH));
+      push("selfie_image_pixel_config", CAPTURE_IMAGE_PIXEL_CONFIG);
+    }
+    if (this._cameraName) {
+      push("camera_name", this._cameraName);
+    }
+    if (this._devicePositions.length > 0) {
+      push("device_positions", JSON.stringify(this._devicePositions));
+      if (this._deviceMovementDetected !== null) {
+        push("device_movement_detected", String(this._deviceMovementDetected));
+      }
+    }
+
+    const sideKey = (side: DocumentSide) =>
+      side === DocumentSide.Back ? "back" : "front";
+    for (const side of [DocumentSide.Front, DocumentSide.Back]) {
+      const key = sideKey(side);
+      const telemetry = this._documentCaptureTelemetry.get(side);
+      if (telemetry) {
+        push(
+          `document_${key}_capture_duration_ms`,
+          String(telemetry.durationMs),
+        );
+        push(`document_${key}_capture_retries`, String(telemetry.retries));
+        push(
+          `document_${key}_image_color_depth`,
+          String(CAPTURE_IMAGE_COLOR_DEPTH),
+        );
+        push(`document_${key}_image_pixel_config`, CAPTURE_IMAGE_PIXEL_CONFIG);
+      }
+    }
+    // Per-image original + final compressed sizes are stamped in the repository around the
+    // compression pass (it owns both the before and after byte counts), not here.
+    return entries;
+  }
+
   private _precedingStepIsDocumentCapture(index: number): boolean {
     const preceding = this._steps[index - 1];
     return (
@@ -619,11 +780,16 @@ export class FlowNavigationManager {
     // make() so a mid-flow rotation is captured. resolvedSdkConfig drives
     // sdk_config_source + image_width/height provenance.
     const baseMetadata = this._metadataProvider.make(this.resolvedSdkConfig);
-    const originEntries = this._documentImageOriginEntries();
-    const metadata =
-      originEntries.length > 0
-        ? baseMetadata.withAdditionalEntries(originEntries)
-        : baseMetadata;
+    // Append the per-side document origins plus the partner's builder setup and
+    // the active detection models, all as flat wire entries.
+    // configurationMetadataEntries always contributes the builder + model config objects, so
+    // there is always at least one extra entry to append.
+    const extraEntries = [
+      ...this._documentImageOriginEntries(),
+      ...this._captureTelemetryEntries(),
+      ...configurationMetadataEntries(config),
+    ];
+    const metadata = baseMetadata.withAdditionalEntries(extraEntries);
 
     switch (jobType) {
       // enableEnhancedLiveness is a screen-level capture flag, not a
@@ -960,16 +1126,16 @@ export class FlowNavigationManager {
   }
 
   /**
-   * Decode the `sdk_config` JWT claim. `undefined` for offline mode,
-   * no token, or no valid claim — SDK defaults apply in those cases.
+   * Decode the partner JWT into its claims (`sdk_config`, `partner_id`). `undefined` for offline
+   * mode, no token, or an unparseable token — SDK defaults apply in those cases.
    */
-  private static _decodeSdkConfig(
+  private static _decodeToken(
     configuration: FlowConfigurationSnapshot,
-  ): SdkConfig | undefined {
+  ): DecodedToken | undefined {
     if (configuration.config?.allowOfflineMode) return undefined;
     const token = configuration.network?.config?.token;
     if (!token || token.length === 0) return undefined;
-    return decodeSmileIDToken(token)?.sdkConfig;
+    return decodeSmileIDToken(token);
   }
 
   private _notify(): void {

package/src/presentation/flow/model/instruction_guideline.ts

@@ -12,4 +12,10 @@ export type InstructionGuideline = {
   readonly image: FC<{ readonly width?: number; readonly height?: number }>;
   readonly label: (localizations: UseSmileIDLocalizations) => string;
   readonly status: GuidelineStatus;
+  /**
+   * Visible-card size (device-independent px) for a self-contained document
+   * illustration (the SVG paints its own card). Set ⇒ document-card tile;
+   * omitted ⇒ selfie tile (framed card + pill).
+   */
+  readonly card?: { readonly width: number; readonly height: number };
 };

package/src/presentation/flow/model/instructions_defaults.ts

@@ -1,10 +1,18 @@
 import type { AnimationObject } from "lottie-react-native";
 import {
   SiGuidelineAccessories,
-  SiGuidelineDocumentGood,
-  SiGuidelineDocumentNotBlurry,
-  SiGuidelineDocumentNotCropped,
-  SiGuidelineDocumentNotReflective,
+  SiGuidelineDocumentGenericGood,
+  SiGuidelineDocumentGenericNotBlurry,
+  SiGuidelineDocumentGenericNotCropped,
+  SiGuidelineDocumentGenericNotReflective,
+  SiGuidelineDocumentGreenBookGood,
+  SiGuidelineDocumentGreenBookNotBlurry,
+  SiGuidelineDocumentGreenBookNotCropped,
+  SiGuidelineDocumentGreenBookNotReflective,
+  SiGuidelineDocumentPassportGood,
+  SiGuidelineDocumentPassportNotBlurry,
+  SiGuidelineDocumentPassportNotCropped,
+  SiGuidelineDocumentPassportNotReflective,
   SiGuidelineGood,
   SiGuidelineMultipleFaces,
   SiGuidelinePoorLighting,
@@ -73,34 +81,104 @@ export const SELFIE_GUIDELINES: readonly InstructionGuideline[] = Object.freeze(
   SELFIE_GUIDELINE_ENTRIES.map((guideline) => Object.freeze(guideline)),
 );
 
-const DOCUMENT_GUIDELINE_ENTRIES: InstructionGuideline[] = [
-  {
-    image: SiGuidelineDocumentGood,
-    label: (localizations) => localizations.siDocumentGuidelineGood,
-    status: "allowed",
-  },
+// Visible card size (device-independent px) per document guideline tile.
+const DOCUMENT_CARD_LANDSCAPE = Object.freeze({ width: 80, height: 56 });
+const DOCUMENT_CARD_PORTRAIT = Object.freeze({ width: 60, height: 84 });
+
+type DocumentGuidelineImages = {
+  readonly good: InstructionGuideline["image"];
+  readonly notCropped: InstructionGuideline["image"];
+  readonly notBlurry: InstructionGuideline["image"];
+  readonly notReflective: InstructionGuideline["image"];
+};
+
+/**
+ * Build the four document-capture guidelines (good + not cropped / blurry /
+ * reflective) for one document type. The order and labels are shared; only the
+ * per-type artwork and card size differ. Allocated once and deeply frozen.
+ */
+function buildDocumentGuidelines(
+  images: DocumentGuidelineImages,
+  card: { readonly width: number; readonly height: number },
+): readonly InstructionGuideline[] {
+  const entries: InstructionGuideline[] = [
+    {
+      image: images.good,
+      label: (localizations) => localizations.siDocumentGuidelineGood,
+      status: "allowed",
+      card,
+    },
+    {
+      image: images.notCropped,
+      label: (localizations) => localizations.siDocumentGuidelineNotCropped,
+      status: "blocked",
+      card,
+    },
+    {
+      image: images.notBlurry,
+      label: (localizations) => localizations.siDocumentGuidelineNotBlurry,
+      status: "blocked",
+      card,
+    },
+    {
+      image: images.notReflective,
+      label: (localizations) => localizations.siDocumentGuidelineNotReflective,
+      status: "blocked",
+      card,
+    },
+  ];
+  return Object.freeze(entries.map((guideline) => Object.freeze(guideline)));
+}
+
+/** Generic-document capture guidelines (landscape card). */
+export const DOCUMENT_GUIDELINES_GENERIC = buildDocumentGuidelines(
   {
-    image: SiGuidelineDocumentNotCropped,
-    label: (localizations) => localizations.siDocumentGuidelineNotCropped,
-    status: "blocked",
+    good: SiGuidelineDocumentGenericGood,
+    notCropped: SiGuidelineDocumentGenericNotCropped,
+    notBlurry: SiGuidelineDocumentGenericNotBlurry,
+    notReflective: SiGuidelineDocumentGenericNotReflective,
   },
+  DOCUMENT_CARD_LANDSCAPE,
+);
+
+/** Passport capture guidelines (landscape card). */
+export const DOCUMENT_GUIDELINES_PASSPORT = buildDocumentGuidelines(
   {
-    image: SiGuidelineDocumentNotBlurry,
-    label: (localizations) => localizations.siDocumentGuidelineNotBlurry,
-    status: "blocked",
+    good: SiGuidelineDocumentPassportGood,
+    notCropped: SiGuidelineDocumentPassportNotCropped,
+    notBlurry: SiGuidelineDocumentPassportNotBlurry,
+    notReflective: SiGuidelineDocumentPassportNotReflective,
   },
+  DOCUMENT_CARD_LANDSCAPE,
+);
+
+/** South Africa green book capture guidelines (portrait card). */
+export const DOCUMENT_GUIDELINES_GREEN_BOOK = buildDocumentGuidelines(
   {
-    image: SiGuidelineDocumentNotReflective,
-    label: (localizations) => localizations.siDocumentGuidelineNotReflective,
-    status: "blocked",
+    good: SiGuidelineDocumentGreenBookGood,
+    notCropped: SiGuidelineDocumentGreenBookNotCropped,
+    notBlurry: SiGuidelineDocumentGreenBookNotBlurry,
+    notReflective: SiGuidelineDocumentGreenBookNotReflective,
   },
-];
+  DOCUMENT_CARD_PORTRAIT,
+);
 
-/** Default document-capture guidelines — allocated once and deeply frozen. */
-export const DOCUMENT_GUIDELINES: readonly InstructionGuideline[] =
-  Object.freeze(
-    DOCUMENT_GUIDELINE_ENTRIES.map((guideline) => Object.freeze(guideline)),
-  );
+/**
+ * Resolve the document-capture guidelines for a document type. Falls back to
+ * the generic set when the type is unset or has no dedicated artwork.
+ */
+export function documentGuidelines(
+  documentType: DocumentType | undefined,
+): readonly InstructionGuideline[] {
+  switch (documentType?.kind) {
+    case "southAfricaGreenBook":
+      return DOCUMENT_GUIDELINES_GREEN_BOOK;
+    case "passport":
+      return DOCUMENT_GUIDELINES_PASSPORT;
+    default:
+      return DOCUMENT_GUIDELINES_GENERIC;
+  }
+}
 
 /**
  * Resolve the document hero animation for a document type. Falls back to the

package/src/presentation/flow/screen/orchestrated_capture_screen.tsx

@@ -9,6 +9,7 @@ import type {
 } from "@smileid/usesmileid_bridge";
 import {
   CaptureReadyEventKind,
+  DeviceIntegrityProvider,
   DocumentSide,
   ImageType,
 } from "@smileid/usesmileid_bridge";
@@ -21,6 +22,7 @@ import { resolveFaceSessionConfig } from "./helpers/face_session_config";
 import { useCaptureOrientationLock } from "../../screen/helpers/use_capture_orientation_lock";
 import { resolveJpegQuality } from "../../../data/model/sdk_config_capture";
 import { UseSmileIDCaptureScreen } from "../../screen/use_smile_id_capture_screen";
+import { defaultLightTheme } from "../../theme/theme";
 import { UseSmileIDDocumentBackInstructions } from "../../screen/use_smile_id_document_back_instructions";
 import { useFlowNavigation } from "../flow_navigation_context";
 import { UseSmileIDOrchestratedScreenHost } from "./use_smile_id_orchestrated_screen_host";
@@ -166,24 +168,37 @@ export function OrchestratedCaptureScreen({
         }
         return (
           <UseSmileIDCaptureScreen
+            // Remount per document side so the camera resets between front and back captures.
+            key={
+              captureType === CaptureType.document
+                ? `document-capture-${currentDocumentSide}`
+                : "capture"
+            }
             captureType={captureType}
             analyzer={analyzer}
+            // Capture is always light; pass the partner's resolved light tokens
+            // so partner colours still apply (the screen forces light internally).
+            theme={
+              navigationManager.configuration.theme?.light ?? defaultLightTheme
+            }
             enableEnhancedLiveness={
               configuration.selfieConfig?.enableEnhancedLiveness ?? false
             }
             {...(captureType === CaptureType.document && documentConfig
               ? {
-                  // Partner override wins, then the document type's own ratio,
-                  // then the orientation default (landscape ID / portrait card).
+                  // Type ratio → partner override → orientation default; matches
+                  // the preview/processing frames so all three share one shape.
                   knownIdAspectRatio:
-                    documentConfig.knownIdAspectRatio ??
-                    documentType?.knownAspectRatio ??
+                    documentConfig.resolvedAspectRatio ??
                     defaultFrameAspectRatio(
                       documentType?.orientation ?? "Landscape",
                     ),
                   captureMode: documentConfig.captureMode,
                   allowGalleryUpload: documentConfig.allowGalleryUpload,
                   documentSide: currentDocumentSide,
+                  ...(documentType?.kind
+                    ? { documentTypeKind: documentType.kind }
+                    : {}),
                   onDocumentOrigin: (origin) =>
                     navigationManager.recordDocumentImageOrigin(
                       currentDocumentSide,
@@ -207,7 +222,7 @@ export function OrchestratedCaptureScreen({
               }
               onBack();
             }}
-            onCaptureComplete={(events) => {
+            onCaptureComplete={(events, telemetry) => {
               const primary = pickPrimaryCaptureUrl(events, captureType);
               if (!primary) {
                 // Pipeline finished without the expected artifact — stay so the user can retry.
@@ -218,9 +233,10 @@ export function OrchestratedCaptureScreen({
               // (blank partnerId → native no-op). Context is rebound per
               // capture because partnerConfig may change across re-renders
               // (partner builder closures are not memoised).
-              const partnerId =
-                navigationManager.configuration.network?.config?.partnerConfig
-                  ?.partnerId ?? "";
+              //
+              // `navigationManager.partnerId` resolves the JWT's canonical partner_id (e.g.
+              // "002"), falling back to the config value — see FlowNavigationManager.partnerId.
+              const partnerId = navigationManager.partnerId;
               const imageTypeForCapture: ImageTypeId =
                 captureType === CaptureType.selfie
                   ? ImageType.Selfie
@@ -234,16 +250,33 @@ export function OrchestratedCaptureScreen({
                 )
                 .map((event) => event.url);
 
-              void SmileExifTagger.setContext({ partnerId })
+              // Source the device fingerprint from the same native signal the metadata
+              // payload uses so the EXIF tag's `fingerprint` matches it. `signals()` is
+              // fail-open (resolves with `""` if unavailable); omit it when blank so a
+              // capture never ships an empty fingerprint that shadows a real one.
+              void DeviceIntegrityProvider.signals()
+                .then(({ fingerprint }) =>
+                  SmileExifTagger.setContext({
+                    partnerId,
+                    ...(fingerprint ? { fingerprint } : {}),
+                  }),
+                )
                 .then(() =>
                   SmileExifTagger.finalize(primary, imageTypeForCapture),
                 )
-                .finally(() => {
+                .finally(async () => {
                   if (captureType === CaptureType.selfie) {
                     navigationManager.setCapturedSelfie(primary, livenessUrls);
+                    navigationManager.recordSelfieCaptureTelemetry(telemetry);
                     onNavigateNext();
                     return;
                   }
+                  // Document: record this side's capture telemetry before advancing.
+                  // Image sizes are measured in the repository around the compression pass.
+                  navigationManager.recordDocumentCaptureTelemetry(
+                    currentDocumentSide,
+                    telemetry,
+                  );
                   if (
                     capturesBack &&
                     currentDocumentSide === DocumentSide.Front

package/src/presentation/flow/screen/orchestrated_instructions_screen.tsx

@@ -87,6 +87,7 @@ function OrchestratedInstructionsContent({
       showAttribution={resolved.showAttribution}
       showHeroOval={resolved.showHeroOval}
       showHeroOvalProgress={resolved.showHeroOvalProgress}
+      showCardBackground={resolved.showCardBackground}
       {...(configuration.continueButton
         ? {
             // Adapt the config slot `{ onClick, enabled }` to the screen's

package/src/presentation/flow/screen/orchestrated_preview_screen.tsx

@@ -2,6 +2,7 @@ import type { PreviewConfigBuilder } from "../dsl/builder/screens_builder";
 import { UseSmileIDPreviewScreen } from "../../screen/use_smile_id_preview_screen";
 import { UseSmileIDDocumentPreviewScreen } from "../../screen/use_smile_id_document_preview_screen";
 import { UseSmileIDOrchestratedScreenHost } from "./use_smile_id_orchestrated_screen_host";
+import { defaultFrameAspectRatio } from "../../../core/models/document_type";
 
 export type OrchestratedPreviewScreenProps = {
   readonly configuration: PreviewConfigBuilder;
@@ -23,8 +24,9 @@ export function OrchestratedPreviewScreen({
           const documentPath = navigationManager.currentDocumentPreviewPath();
           return (
             <UseSmileIDDocumentPreviewScreen
-              documentOrientation={
-                navigationManager.documentType?.orientation ?? "Landscape"
+              documentAspectRatio={
+                navigationManager.documentFrameAspectRatio ??
+                defaultFrameAspectRatio("Landscape")
               }
               showAttribution={configuration.showAttribution}
               {...(documentPath !== undefined

package/src/presentation/flow/screen/orchestrated_processing_screen.tsx

@@ -66,7 +66,7 @@ function ProcessingScreenBody(props: ProcessingScreenBodyProps) {
   const documentImageUri = requiresDocument(jobType)
     ? navigationManager.captured.frontDocumentPath
     : undefined;
-  const documentOrientation = navigationManager.documentType?.orientation;
+  const documentAspectRatio = navigationManager.documentFrameAspectRatio;
 
   return (
     <UseSmileIDProcessingScreen
@@ -75,8 +75,8 @@ function ProcessingScreenBody(props: ProcessingScreenBodyProps) {
       showProgressPercentage={props.processingConfig.showProgressPercentage}
       showAttribution={props.processingConfig.showAttribution}
       {...(documentImageUri !== undefined ? { documentImageUri } : {})}
-      {...(documentImageUri !== undefined && documentOrientation !== undefined
-        ? { documentOrientation }
+      {...(documentImageUri !== undefined && documentAspectRatio !== undefined
+        ? { documentAspectRatio }
         : {})}
       {...(navigationManager.captured.selfiePath !== undefined
         ? { capturedSelfiePath: navigationManager.captured.selfiePath }

package/src/presentation/flow/validation/__tests__/job_type_validator.test.ts

@@ -667,6 +667,70 @@ describe("DocumentJobTypeValidator — Android-parity rules", () => {
       issues.some((i) => i instanceof InvalidJobTypeScreenConfigException),
     ).toBe(false);
   });
+
+  it("rejects SouthAfricaGreenBook for EnhancedDocumentVerification", () => {
+    const greenBookStep = (() => {
+      const config = new CaptureConfigBuilder();
+      config.captureType = CaptureType.document;
+      config.document((d) => {
+        d.documentType = DocumentType.SouthAfricaGreenBook;
+      });
+      return { kind: "capture" as const, config };
+    })();
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        greenBookStep,
+        previewStep(),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.enhancedDocumentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      enhancedDocumentVerificationParams: validEnhancedDocumentParams,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "South Africa Green Book is not supported for Enhanced Document Verification",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("accepts SouthAfricaGreenBook for DocumentVerification", () => {
+    const greenBookStep = (() => {
+      const config = new CaptureConfigBuilder();
+      config.captureType = CaptureType.document;
+      config.document((d) => {
+        d.documentType = DocumentType.SouthAfricaGreenBook;
+      });
+      return { kind: "capture" as const, config };
+    })();
+    const issues = run({
+      steps: [
+        consentStep(),
+        captureStep(CaptureType.selfie),
+        greenBookStep,
+        previewStep(),
+        processingStep(),
+      ],
+      network: validNetwork(JobType.documentVerification),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      documentVerificationParams: validDocumentParams,
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes("South Africa Green Book is not supported"),
+      ),
+    ).toBe(false);
+  });
 });
 
 describe("NonCaptureJobTypeValidator — Android-parity rules", () => {