@myazahq/kyc-sdk-react-native 2.0.2 → 2.2.0

package/src/capture/documentTextGate.ts

@@ -0,0 +1,171 @@
+import {
+  verifyDocumentIdentity,
+  type DocumentGuidance,
+  type DocumentHint,
+} from './documentIdentity';
+
+// ---------------------------------------------------------------------------
+// Text-based auto-capture gate.
+//
+// Auto-capture rides on-device TEXT recognition — a KYC document is text-dense,
+// and a check-digit-valid MRZ is an even stronger "framed & readable" signal.
+// The recogniser is already in the build for the MRZ step, so this needs no new
+// native code and works identically on both platforms.
+//
+// Three questions before firing:
+//
+//   • IDENTITY — is this the document the user picked? (documentIdentity.ts)
+//   • FRAMING  — is it presented like a document? Measured from the region the
+//     recognised text occupies, which is the only geometry text recognition
+//     gives us. It is a proxy for the document's extent, not its edges, so the
+//     thresholds are deliberately loose: they exist to reject text sprawling
+//     across the whole frame (a screen, a page of prose) or a document too far
+//     away to read — not to fine-tune composition.
+//   • STABILITY — held steady for a dwell, so the shot isn't taken mid-move.
+//     This is what stops the blurry captures that make auto-capture feel worse
+//     than a manual shutter.
+//
+// Pure logic (no camera or ML dependency) so the thresholds are unit-tested
+// rather than tuned by trial on a device. Ported from the Flutter SDK's
+// document_text_gate.dart — keep the two in step.
+// ---------------------------------------------------------------------------
+
+/** Normalised (0..1) bounding box of all recognised text. */
+export interface TextBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface TextGateOptions {
+  /** Minimum recognised text lines to treat the frame as showing a document. */
+  minLines?: number;
+  /** Smallest share of the frame the text region may cover. */
+  minTextArea?: number;
+  /** Largest share. Text over nearly the whole frame is a screen, not a card. */
+  maxTextArea?: number;
+  /** How far the text region's centre may sit from the frame's centre. */
+  maxOffCentre?: number;
+  /** How long the framing must hold before firing. */
+  dwellMs?: number;
+}
+
+export interface UpdateOptions {
+  country: string;
+  idType: string;
+  /** Which face is up. The back skips keyword identity — see documentIdentity. */
+  side?: 'front' | 'back';
+  bounds?: TextBounds | null;
+  requireMrz?: boolean;
+  hasValidMrz?: boolean;
+  mrzAlreadyCaptured?: boolean;
+  now?: number;
+}
+
+export class DocumentTextGate {
+  private readonly minLines: number;
+  private readonly minTextArea: number;
+  private readonly maxTextArea: number;
+  private readonly maxOffCentre: number;
+  private readonly dwellMs: number;
+
+  private heldSince: number | null = null;
+  private fired = false;
+
+  constructor(opts: TextGateOptions = {}) {
+    this.minLines = opts.minLines ?? 5;
+    this.minTextArea = opts.minTextArea ?? 0.06;
+    this.maxTextArea = opts.maxTextArea ?? 0.82;
+    this.maxOffCentre = opts.maxOffCentre ?? 0.3;
+    this.dwellMs = opts.dwellMs ?? 700;
+  }
+
+  get hasFired(): boolean {
+    return this.fired;
+  }
+
+  /** Progress through the stability dwell, 0..1 — drives the UI's scan ring. */
+  progress(now: number): number {
+    if (this.heldSince == null) return 0;
+    if (this.dwellMs <= 0) return 1;
+    return Math.min(1, Math.max(0, (now - this.heldSince) / this.dwellMs));
+  }
+
+  /** Feeds one frame's recognised `lines`. */
+  update(lines: string[], o: UpdateOptions): DocumentGuidance {
+    const now = o.now ?? Date.now();
+    if (this.fired) return { framing: 'ready', hint: 'captured' };
+
+    const identity = verifyDocumentIdentity(lines, {
+      country: o.country,
+      idType: o.idType,
+      side: o.side ?? 'front',
+      requireValidMrz: o.requireMrz ?? false,
+      hasValidMrz: o.hasValidMrz ?? false,
+      mrzAlreadyCaptured: o.mrzAlreadyCaptured ?? false,
+    });
+    if (!identity.identified) {
+      this.heldSince = null;
+      return {
+        framing: identity.hint === 'wrongDocument' ? 'wrongShape' : 'none',
+        hint: identity.hint,
+      };
+    }
+
+    // A check-digit-valid MRZ read from THIS frame is conclusive: only a travel
+    // document carries one, and it only validates when legible — so it proves
+    // identity and readability at once, and the shot need not wait out a dwell.
+    // (A merely STORED MRZ does not qualify — see `mrzAlreadyCaptured` — or
+    // every retake would fire on its first frame.)
+    if (o.hasValidMrz) {
+      this.fired = true;
+      return { framing: 'ready', hint: 'holdStill' };
+    }
+
+    const framingHint = this.framingProblem(o.bounds ?? null, lines.length, o.side ?? 'front');
+    if (framingHint) {
+      this.heldSince = null;
+      return { framing: 'adjust', hint: framingHint };
+    }
+
+    if (this.heldSince == null) this.heldSince = now;
+    if (now - this.heldSince >= this.dwellMs) {
+      this.fired = true;
+      return { framing: 'ready', hint: 'holdStill' };
+    }
+    return { framing: 'holding', hint: 'holdStill' };
+  }
+
+  /** Why the text region isn't acceptably framed, or null when it is. */
+  private framingProblem(
+    bounds: TextBounds | null,
+    lineCount: number,
+    side: 'front' | 'back',
+  ): DocumentHint | null {
+    // Card backs are text-SPARSE by design — a PVC's is mostly barcode with a
+    // few small print lines — so the front's density thresholds would hold the
+    // gate at "move closer" forever on a perfectly framed back. The rect
+    // detector (where present) still guards the geometry.
+    const minLines = side === 'back' ? Math.min(3, this.minLines) : this.minLines;
+    const minTextArea = side === 'back' ? Math.min(0.03, this.minTextArea) : this.minTextArea;
+    if (!bounds) {
+      // No geometry from this platform — fall back to text density alone.
+      return lineCount < minLines ? 'moveCloser' : null;
+    }
+    const area = Math.min(1, Math.max(0, bounds.width * bounds.height));
+    if (area < minTextArea) return 'moveCloser';
+    if (area > this.maxTextArea) return 'moveBack';
+
+    const offCentreX = Math.abs(bounds.x + bounds.width / 2 - 0.5);
+    const offCentreY = Math.abs(bounds.y + bounds.height / 2 - 0.5);
+    if (offCentreX > this.maxOffCentre || offCentreY > this.maxOffCentre) return 'centre';
+    return null;
+  }
+
+  /** Clears the latch so the next side (or a retake) starts a fresh dwell. */
+  reset(): void {
+    this.heldSince = null;
+    this.fired = false;
+  }
+}

package/src/capture/hints.ts

@@ -0,0 +1,57 @@
+import type { DocumentHint } from './documentIdentity';
+
+// ---------------------------------------------------------------------------
+// Capture hint copy.
+//
+// One instruction per rejection reason. Deliberately imperative and specific:
+// a single message ("Align your ID within the frame") told the user nothing
+// about WHICH way to move, and the commonest failure — holding the document
+// too close — is the one people cannot guess, because the instinct on "it isn't
+// reading" is to move nearer still.
+//
+// Copy is document-agnostic. `label` is the ID's own name so the same strings
+// serve a passport, a card or a licence without special-casing any of them.
+//
+// Verbatim from the Flutter SDK's capture_hints.dart — keep the two identical.
+// ---------------------------------------------------------------------------
+
+export function documentHintText(hint: DocumentHint, label: string): string {
+  switch (hint) {
+    case 'searching':
+      return `Point the camera at your ${label}`;
+    case 'moreLight':
+      return 'Too dark — move somewhere brighter';
+    case 'wrongDocument':
+      return `That doesn't look like a ${label}`;
+    case 'showMrz':
+      return 'Include the code strip along the bottom of the page';
+    case 'moveCloser':
+      return 'Move closer';
+    case 'moveBack':
+      // The one users don't reach for on their own.
+      return `Move back a little — fit the whole ${label} in view`;
+    case 'centre':
+      return `Centre your ${label} in the frame`;
+    case 'holdStill':
+      return 'Hold still…';
+    case 'captured':
+      return 'Got it';
+    default:
+      return `Point the camera at your ${label}`;
+  }
+}
+
+/**
+ * True when the hint is asking the user to change something, so the UI can
+ * give it more weight than the neutral prompts.
+ */
+export function documentHintIsAction(hint: DocumentHint): boolean {
+  return (
+    hint === 'moreLight' ||
+    hint === 'wrongDocument' ||
+    hint === 'showMrz' ||
+    hint === 'moveCloser' ||
+    hint === 'moveBack' ||
+    hint === 'centre'
+  );
+}

package/src/capture/index.ts

@@ -0,0 +1,24 @@
+// Auto-capture: the pure decision logic behind "shoot now".
+//
+// Barrel-only surface — screens import from here, never the internals, so the
+// thresholds stay in one testable place.
+export {
+  DOCUMENT_SIGNALS,
+  countSignalHits,
+  detectDocumentType,
+  hasDocumentSignals,
+  hasMrzLines,
+  type DocumentTypeMatch,
+} from './documentSignals';
+export {
+  documentCarriesMrz,
+  verifyDocumentIdentity,
+  type DocumentFraming,
+  type DocumentGuidance,
+  type DocumentHint,
+  type DocumentIdentityResult,
+} from './documentIdentity';
+export { DocumentTextGate, type TextBounds, type TextGateOptions } from './documentTextGate';
+export { documentHintText, documentHintIsAction } from './hints';
+export { useAutoCapture, type AutoCaptureState } from './useAutoCapture';
+export { hasRectDetector, rectFramingProblem, type RectGateOptions } from './rectDetector';

package/src/capture/rectDetector.ts

@@ -0,0 +1,84 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { BoxedHybridObject } from 'react-native-nitro-modules';
+import type { Frame } from 'react-native-vision-camera';
+
+import type { DetectedRect, MyazaRectDetector } from '../specs/MyazaRectDetector.nitro';
+
+// ---------------------------------------------------------------------------
+// Document EDGE detection — the geometry half of auto-capture.
+//
+// iOS only in practice: Apple Vision has a rectangle detector, ML Kit does not,
+// and the Android implementation reports nothing found. Everything here is
+// therefore written to degrade to "no opinion" rather than to block, so a
+// platform without geometry captures exactly as it did before.
+//
+// Geometry NEVER decides alone. An aspect ratio cannot tell a passport from a
+// driver's licence, so a capture that fired on shape would shoot the wrong
+// document — the text gate is what establishes identity, and this only says
+// whether what's there is presented like a document.
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolved LAZILY and re-tried until it appears.
+ *
+ * Creating it at module load fails silently and permanently when this module
+ * evaluates before Nitro's registry is populated (Fast Refresh does this): the
+ * reference stays null for the session and the geometry gate silently becomes a
+ * no-op, which is indistinguishable from a platform that has no detector.
+ *
+ * The BOXED handle is what the worklet unboxes, so it is created alongside on
+ * the JS thread — a worklet cannot construct one itself.
+ */
+function create(): MyazaRectDetector | null {
+  try {
+    return NitroModules.hasHybridObject('MyazaRectDetector')
+      ? NitroModules.createHybridObject<MyazaRectDetector>('MyazaRectDetector')
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+// EAGER, and it has to be — the worklet captures `boxed` at creation, so a null
+// there is permanent on the camera thread and every frame reports no rectangle.
+let detector: MyazaRectDetector | null = create();
+// `let`, not `const`: if the eager create above ran before Nitro's registry was
+// populated, `resolve()` re-creates AND re-boxes. Leaving this const meant a
+// late resolution produced a working JS-side module with a null worklet handle
+// — the camera thread stayed blind while everything looked fine from JS.
+let boxed: BoxedHybridObject<MyazaRectDetector> | null = detector ? NitroModules.box(detector) : null;
+
+function resolve(): MyazaRectDetector | null {
+  if (!detector) {
+    detector = create();
+    if (detector) boxed = NitroModules.box(detector);
+  }
+  return detector;
+}
+
+/**
+ * Whether this build can measure document edges at all.
+ *
+ * Also the WARM-UP: calling it resolves the module on the JS thread so the
+ * boxed handle exists before the first frame reaches the worklet.
+ */
+export function hasRectDetector(): boolean {
+  return resolve() !== null;
+}
+
+const NOT_FOUND: DetectedRect = {
+  found: false, x: 0, y: 0, width: 0, height: 0, aspect: 0, confidence: 0,
+};
+
+/** Measure the document-like rectangle in a frame. A WORKLET. */
+export function detectRectOnFrame(frame: Frame): DetectedRect {
+  'worklet';
+  if (boxed == null) return NOT_FOUND;
+  try {
+    return boxed.unbox().detectRect(frame);
+  } catch {
+    return NOT_FOUND;
+  }
+}
+
+export { rectFramingProblem, type RectGateOptions, type MeasuredRect } from './rectGate';

package/src/capture/rectGate.ts

@@ -0,0 +1,91 @@
+import type { DocumentHint } from './documentIdentity';
+
+// ---------------------------------------------------------------------------
+// Judging a detected document rectangle — the PURE half of edge detection.
+//
+// Split from rectDetector.ts on purpose: that module binds the native detector
+// and so drags react-native-nitro-modules into whatever imports it. The
+// thresholds below are the part worth testing, and they must be reachable in
+// CI with no device and no native build.
+//
+// Geometry NEVER decides alone. An aspect ratio cannot tell a passport from a
+// driver's licence, so a capture that fired on shape would shoot the wrong
+// document — the text gate establishes identity; this only says whether what is
+// there is presented like a document.
+// ---------------------------------------------------------------------------
+
+/** The measured box, as the native detector reports it (normalised 0..1). */
+export interface MeasuredRect {
+  found: boolean;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  aspect: number;
+  confidence: number;
+}
+
+export interface RectGateOptions {
+  /** Expected width ÷ height: 1.586 for ID cards, 1.42 for a passport page. */
+  expectedAspect: number;
+  /** How far the observed aspect may stray, as a fraction of the expected. */
+  aspectTolerance?: number;
+  /** Smallest share of the frame the document may cover. */
+  minArea?: number;
+  /** Largest share — beyond this the corners are being cut off. */
+  maxArea?: number;
+  /** Clearance every edge must keep from the frame border. */
+  minMargin?: number;
+}
+
+/**
+ * Judge a detected rectangle. Returns the framing complaint, or null when the
+ * shape is acceptable — and null ALSO when nothing was detected, because
+ * "no geometry" must not read as "badly framed" on a platform that cannot
+ * measure. The text gate still has to agree either way.
+ */
+export function rectFramingProblem(
+  rect: MeasuredRect | null,
+  {
+    expectedAspect,
+    aspectTolerance = 0.35,
+    minArea = 0.12,
+    maxArea = 0.92,
+    minMargin = 0.01,
+  }: RectGateOptions,
+): DocumentHint | null {
+  if (!rect || !rect.found) return null;
+
+  // SHAPE. The detector will happily segment a book, a receipt or a laptop;
+  // aspect is what tells an ID document apart from them.
+  //
+  // Compared against BOTH orientations: a document held in landscape and one
+  // held in portrait are the same document, and the detector reports whatever
+  // it saw. Rejecting the rotated case would refuse a perfectly good frame.
+  const observed = rect.aspect;
+  const alt = observed > 0 ? 1 / observed : 0;
+  const matches =
+    Math.abs(observed - expectedAspect) <= expectedAspect * aspectTolerance ||
+    Math.abs(alt - expectedAspect) <= expectedAspect * aspectTolerance;
+  if (!matches) return 'wrongDocument';
+
+  // SIZE. Big enough that the crop keeps the detail OCR and the MRZ need, but
+  // not so big that it is overflowing the frame.
+  const area = rect.width * rect.height;
+  if (area < minArea) return 'moveCloser';
+  if (area > maxArea) return 'moveBack';
+
+  // MARGIN. Every edge clear of the border, so all four corners are in shot. A
+  // document cropped flush to an edge loses characters, and OCR reads edges
+  // worst.
+  if (
+    rect.x < minMargin ||
+    rect.y < minMargin ||
+    rect.x + rect.width > 1 - minMargin ||
+    rect.y + rect.height > 1 - minMargin
+  ) {
+    return 'moveBack';
+  }
+
+  return null;
+}

package/src/capture/useAutoCapture.ts

@@ -0,0 +1,198 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useFrameOutput } from 'react-native-vision-camera';
+import { runOnJS } from 'react-native-worklets';
+
+import { hasTextRecognizer, recognizeAllLines } from '../mrz/textRecognizer';
+import { extractMrz } from '../mrz/extract';
+import type { MrzScan } from '../mrz/parse';
+import { DocumentTextGate } from './documentTextGate';
+import { documentCarriesMrz, type DocumentGuidance } from './documentIdentity';
+import { detectRectOnFrame, hasRectDetector } from './rectDetector';
+import { rectFramingProblem } from './rectGate';
+import type { DetectedRect } from '../specs/MyazaRectDetector.nitro';
+
+// ---------------------------------------------------------------------------
+// Auto-capture: shoot when the document is identified, framed and still.
+//
+// Detection is an ACCELERATOR, never the only route — the manual shutter stays
+// live throughout, and a build without the native recogniser simply never fires
+// this, leaving the manual flow exactly as it was.
+//
+// Reading text per frame also banks the MRZ ahead of the shutter, so the chip
+// step needs no second scan of the same passport. That is the main reason the
+// gate reads text rather than just measuring edges.
+// ---------------------------------------------------------------------------
+
+/** How often a frame is actually recognised. OCR is far slower than 30fps. */
+const DETECT_INTERVAL_MS = 250;
+
+export interface AutoCaptureOptions {
+  /** Off while capturing/uploading, on a preview, or when there is no camera. */
+  enabled: boolean;
+  country: string;
+  idType: string;
+  /**
+   * Which face is up. The back of a card carries none of the front's identity
+   * keywords (a PVC back is barcode and small print), so the gate must not
+   * demand them there — the front capture moments earlier established what
+   * document this is.
+   */
+  side?: 'front' | 'back';
+  /** The chip step wants the MRZ, so hold out for a check-digit-valid read. */
+  requireMrz?: boolean;
+  /** An MRZ is already stored from an earlier frame or a previous side. */
+  mrzAlreadyCaptured?: boolean;
+  /** Called once per fresh MRZ read — bank it for the chip step. */
+  onMrz?: (scan: MrzScan) => void;
+  /** Called once when the gate decides to shoot. */
+  onFire: () => void;
+  /** Expected width ÷ height, for the geometry check where it is available. */
+  guideAspect?: number;
+  /**
+   * Changing this starts a fresh dwell.
+   *
+   * Load-bearing for two-sided documents: the front and the back are the same
+   * `idType`, and the viewfinder does not remount between them — so without a
+   * key that actually changes, the gate stays LATCHED from the front and the
+   * back never auto-captures. Pass the side (or anything else that identifies
+   * "this is a new thing to look at").
+   */
+  resetKey?: string;
+}
+
+export interface AutoCaptureState {
+  /** Attach to `<Camera outputs={[...]}>`. */
+  frameOutput: ReturnType<typeof useFrameOutput>;
+  guidance: DocumentGuidance;
+  /** 0..1 through the stability dwell — drives the scan ring. */
+  progress: number;
+  /** Whether a check-digit-valid MRZ has been read this session. */
+  hasMrz: boolean;
+  /** Start a fresh dwell (new side, or a retake). */
+  reset: () => void;
+}
+
+const INITIAL: DocumentGuidance = { framing: 'none', hint: 'searching' };
+
+export function useAutoCapture({
+  enabled,
+  country,
+  idType,
+  side = 'front',
+  requireMrz = false,
+  mrzAlreadyCaptured = false,
+  onMrz,
+  onFire,
+  guideAspect = 1.586,
+  resetKey,
+}: AutoCaptureOptions): AutoCaptureState {
+  // RESOLVE FIRST, synchronously, before `useFrameOutput` below builds the
+  // worklet. Both modules hand the worklet a BOXED handle that only the JS
+  // thread can create, and the worklet captures that handle when it is CREATED
+  // — so a handle still unresolved at that moment is null on the camera thread
+  // forever, and every frame reports "no text, no rectangle".
+  //
+  // Module-import time is too early (Nitro's registry may not be populated) and
+  // a useEffect is too late (it runs after the worklet exists). The component
+  // body is the one place that is both.
+  hasTextRecognizer();
+  hasRectDetector();
+
+  const gate = useMemo(() => new DocumentTextGate(), []);
+  const [guidance, setGuidance] = useState<DocumentGuidance>(INITIAL);
+  const [progress, setProgress] = useState(0);
+  const [hasMrz, setHasMrz] = useState(false);
+
+  const lastDetectRef = useRef(0);
+  const firedRef = useRef(false);
+  // Refs, not deps: the worklet callback is created once, and re-creating it on
+  // every guidance change would tear down the frame output mid-stream.
+  const optsRef = useRef({ enabled, country, idType, side, requireMrz, mrzAlreadyCaptured, onMrz, onFire, guideAspect });
+  optsRef.current = { enabled, country, idType, side, requireMrz, mrzAlreadyCaptured, onMrz, onFire, guideAspect };
+
+  // Deliberately does NOT clear `hasMrz`: the MRZ belongs to the document, not
+  // to the side being photographed, and clearing it would make the chip step
+  // ask for a strip that has already been read.
+  const reset = useCallback(() => {
+    gate.reset();
+    firedRef.current = false;
+    lastDetectRef.current = 0;
+    setGuidance(INITIAL);
+    setProgress(0);
+  }, [gate]);
+
+  // A new side is a new document face: the previous side's dwell and verdict
+  // must not carry over, or the back would fire on the front's decision — and
+  // worse, the gate's `fired` latch would mean it never fires at all.
+  // `idType` alone is NOT enough: both sides of a card share it.
+  useEffect(() => {
+    reset();
+  }, [idType, resetKey, reset]);
+
+  const handleFrame = useCallback((lines: string[], rect: DetectedRect) => {
+    const o = optsRef.current;
+    if (!o.enabled || firedRef.current) return;
+
+    const now = Date.now();
+    if (now - lastDetectRef.current < DETECT_INTERVAL_MS) return;
+    lastDetectRef.current = now;
+
+    // Bank the MRZ whenever one validates — this is what spares the user
+    // scanning the same passport again at the chip step.
+    let freshMrz = false;
+    const scan = extractMrz(lines);
+    if (scan) {
+      freshMrz = true;
+      setHasMrz(true);
+      o.onMrz?.(scan);
+    }
+
+    // GEOMETRY first, where the platform has it. A shape complaint is
+    // actionable on its own ("move back"), and letting it through would mean
+    // running out a stability dwell on a document whose corners are cut off.
+    // Absent a detector this is null and the text gate decides alone.
+    const shapeProblem = rectFramingProblem(rect, { expectedAspect: o.guideAspect });
+    if (shapeProblem) {
+      setGuidance({ framing: 'adjust', hint: shapeProblem });
+      setProgress(0);
+      return;
+    }
+
+    const verdict = gate.update(lines, {
+      country: o.country,
+      idType: o.idType,
+      side: o.side,
+      // The MRZ is a FRONT-side key; the back of a card has no strip to wait for.
+      requireMrz: o.side !== 'back' && (o.requireMrz || documentCarriesMrz(o.idType)),
+      hasValidMrz: freshMrz,
+      mrzAlreadyCaptured: o.mrzAlreadyCaptured,
+      now,
+    });
+    setGuidance(verdict);
+    setProgress(gate.progress(now));
+
+    if (verdict.framing === 'ready' && !firedRef.current) {
+      firedRef.current = true;
+      o.onFire();
+    }
+  }, [gate]);
+
+  const frameOutput = useFrameOutput({
+    pixelFormat: 'yuv',
+    // Recognition runs far longer than a frame interval, so skip whatever
+    // arrives mid-pass rather than queueing it late.
+    dropFramesWhileBusy: true,
+    onFrame: (frame) => {
+      'worklet';
+      const lines = recognizeAllLines(frame);
+      const rect = detectRectOnFrame(frame);
+      frame.dispose();
+      runOnJS(handleFrame)(lines, rect);
+    },
+    onFrameDropped: () => {
+      'worklet';
+    },
+  });
+
+  return { frameOutput, guidance, progress, hasMrz, reset };
+}