@smileid/usesmileid 12.0.2 → 12.1.1

package/src/presentation/screen/__tests__/use_smile_id_capture_screen.test.tsx

@@ -1,1128 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import * as React from "react";
-import {
-  create as createRenderer,
-  act,
-  type ReactTestInstance,
-} from "react-test-renderer";
-import { Pressable, Text } from "react-native";
-import * as VisionCamera from "react-native-vision-camera";
-import * as Brightness from "expo-brightness";
-import { StatusBar } from "react-native";
-import { UseSmileIDCaptureScreen } from "../use_smile_id_capture_screen";
-import { CaptureType } from "../../../core/models/ml_config";
-import { DocumentCaptureMode } from "../../../core/models/document_capture_mode";
-import { mockedTakePhoto } from "../../../__tests__/setup_react_native";
-import { enStrings } from "../../../l10n/strings_en";
-import {
-  UseSmileIDScanStateType,
-  CaptureReadyEventKind,
-} from "@smileid/usesmileid_bridge";
-import type {
-  UseSmileIDScanState,
-  CaptureReadyEvent,
-  FaceScanResult,
-} from "@smileid/usesmileid_bridge";
-import { scriptedFaceScanResults } from "../../../testing/scripted_scan_results";
-import { parseScriptedScenario } from "../../../testing/scenario_loader";
-import { isSessionBoundary } from "../helpers/capture_ui_state";
-import { UseSmileIDFeedbackDebouncer } from "../helpers/feedback_debouncer";
-import { UseSmileIDMotion } from "../../theme/use_smile_id_motion";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-// The shared scenario set lives at the repo root (e2e/scenarios/), outside this
-// package's tsc rootDir (./src), so the test reads selfie-happy-path.json at run
-// time. These minimal ambient decls keep the read typed without pulling
-// @types/node in (which would collide with react-native's global timer types).
-declare module "node:fs" {
-  export function readFileSync(path: string, encoding: "utf8"): string;
-}
-declare module "node:path" {
-  export function dirname(path: string): string;
-  export function join(...parts: string[]): string;
-}
-
-// Capture the screen's per-frame `onResult` so tests can drive synthetic
-// sequences — the vision-camera worklet can't run in vitest, and `onResult`
-// gets a validated result, so this bypasses only the native plugin.
-let capturedOnResult: ((result: FaceScanResult) => void) | null = null;
-vi.mock("../../../camera/use_smile_id_frame_stream", async () => {
-  const actual = await vi.importActual<
-    typeof import("../../../camera/use_smile_id_frame_stream")
-  >("../../../camera/use_smile_id_frame_stream");
-  return {
-    ...actual,
-    useSmileIDFrameStream: (
-      _analyzer: unknown,
-      onResult: (result: FaceScanResult) => void,
-    ) => {
-      capturedOnResult = onResult;
-      return { onFrameResult: () => {} };
-    },
-  };
-});
-
-/**
- * Component-level tests for the capture screen:
- *   - light-only theme on every leaf (forceLightMode propagation)
- *   - camera preview rendered for the correct lens
- *   - permission auto-request fires once on mount
- *   - feedback string follows the overlay state
- *   - start button only present in INSTRUCTION state, gated by readiness
- *   - back button forwards taps
- *   - brightness hook engaged on mount
- *
- * Mocks for `react-native-vision-camera`, `react-native-worklets-core`,
- * `expo-brightness`, `expo-keep-awake` are installed in
- * `setup_react_native.ts`. Tests reset the granted permission contract
- * per-block.
- */
-
-const mockedUseCameraPermission = vi.mocked(VisionCamera.useCameraPermission);
-const mockedUseCameraDevice = vi.mocked(VisionCamera.useCameraDevice);
-const mockedSetBrightness = vi.mocked(Brightness.setBrightnessAsync);
-const mockedGetBrightness = vi.mocked(Brightness.getBrightnessAsync);
-
-function render(element: React.ReactElement) {
-  let tree!: ReturnType<typeof createRenderer>;
-  act(() => {
-    tree = createRenderer(element);
-  });
-  return tree;
-}
-
-function findByTestID(
-  root: ReactTestInstance,
-  testID: string,
-): ReactTestInstance | null {
-  const matches = root.findAllByProps({ testID });
-  return matches[0] ?? null;
-}
-
-function findTextNode(
-  root: ReactTestInstance,
-  expected: string,
-): ReactTestInstance | null {
-  const matches = root.findAll(
-    (node) => {
-      if (node.type !== Text) return false;
-      return collectText(node).includes(expected);
-    },
-    { deep: true },
-  );
-  return matches[0] ?? null;
-}
-
-function collectText(node: ReactTestInstance): string {
-  return node.children
-    .map((child) =>
-      typeof child === "string"
-        ? child
-        : collectText(child as ReactTestInstance),
-    )
-    .join("");
-}
-
-// vision-camera's `CameraDevice` shape — only the fields the screen
-// touches need to be present for tests. The mock returns the same
-// device regardless of position; tests that care about the lens
-// inspect what `useCameraDevice` was called with instead.
-const fakeFrontDevice = {
-  id: "test-front",
-  position: "front" as const,
-  hasFlash: false,
-  hasTorch: false,
-  formats: [],
-  isMultiCam: false,
-  supportsRawCapture: false,
-  supportsLowLightBoost: false,
-  supportsFocus: true,
-  name: "Front Camera (test)",
-} as unknown as ReturnType<typeof VisionCamera.useCameraDevice>;
-
-// Minimal analyzer fixture — the screen reads `frameProcessorPluginName`
-// at render time (to initialise the native frame processor plugin) and
-// calls lifecycle methods from result callbacks. Tests that assert
-// flush/complete behaviour override `flush` per-test.
-function makeFakeAnalyzer() {
-  return {
-    kind: "face",
-    key: "mlkit-face",
-    frameProcessorPluginName: "UseSmileIDTestFrameProcessor",
-    configure: vi.fn(async () => {}),
-    reset: vi.fn(async () => {}),
-    flush: vi.fn(async () => {}),
-    close: vi.fn(async () => {}),
-  } as unknown as React.ComponentProps<
-    typeof UseSmileIDCaptureScreen
-  >["analyzer"];
-}
-const fakeAnalyzer = makeFakeAnalyzer();
-
-describe("UseSmileIDCaptureScreen", () => {
-  beforeEach(() => {
-    mockedGetBrightness.mockReset();
-    mockedGetBrightness.mockResolvedValue(0.5);
-    mockedSetBrightness.mockReset();
-    mockedSetBrightness.mockResolvedValue(undefined);
-    mockedUseCameraPermission.mockReset();
-    mockedUseCameraPermission.mockReturnValue({
-      hasPermission: true,
-      requestPermission: vi.fn(async () => true),
-    });
-    mockedUseCameraDevice.mockReset();
-    mockedUseCameraDevice.mockReturnValue(fakeFrontDevice);
-  });
-
-  it("renders the capture screen container", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    expect(findByTestID(root, "si_capture_screen")).not.toBeNull();
-  });
-
-  it("renders the camera preview when permission is granted", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    const preview = findByTestID(root, "si_capture_camera_preview");
-    expect(preview).not.toBeNull();
-    // Selfie capture uses the front lens; document uses back. The
-    // screen reads its device from `useCameraDevice(facing)` so the
-    // lens choice surfaces as the hook's argument, not a `<Camera>`
-    // prop.
-    expect(mockedUseCameraDevice).toHaveBeenCalledWith("front");
-  });
-
-  it("uses the back lens for document captures", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.document}
-      />,
-    );
-    const preview = findByTestID(root, "si_capture_camera_preview");
-    expect(preview).not.toBeNull();
-    expect(mockedUseCameraDevice).toHaveBeenCalledWith("back");
-  });
-
-  it("uses the back lens for an agent-mode selfie capture", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-        allowAgentMode
-      />,
-    );
-    expect(findByTestID(root, "si_capture_camera_preview")).not.toBeNull();
-    expect(mockedUseCameraDevice).toHaveBeenCalledWith("back");
-  });
-
-  it("shows a placeholder (not the camera) when permission is undetermined", () => {
-    const requestPermission = vi.fn(async () => true);
-    mockedUseCameraPermission.mockReturnValue({
-      hasPermission: false,
-      requestPermission,
-    });
-
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    expect(findByTestID(root, "si_capture_camera_placeholder")).not.toBeNull();
-    expect(findByTestID(root, "si_capture_camera_preview")).toBeNull();
-  });
-
-  it("auto-requests permission once when undetermined", () => {
-    const requestPermission = vi.fn(async () => true);
-    mockedUseCameraPermission.mockReturnValue({
-      hasPermission: false,
-      requestPermission,
-    });
-
-    render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-
-    expect(requestPermission).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not re-prompt when permission is granted", () => {
-    const requestPermission = vi.fn(async () => true);
-    mockedUseCameraPermission.mockReturnValue({
-      hasPermission: true,
-      requestPermission,
-    });
-
-    render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    expect(requestPermission).not.toHaveBeenCalled();
-  });
-
-  it("renders the start button enabled in INSTRUCTION state", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    const start = findByTestID(root, "si_capture_start_button");
-    expect(start).not.toBeNull();
-    // INSTRUCTION is the *only* state where Start Capture renders, and
-    // it's the user's affirmative action to begin the analyzer
-    // pipeline — so it must be enabled. Disabled-during-INSTRUCTION
-    // would leave the user with no way to advance the flow.
-    expect(start!.props.enabled).toBe(true);
-  });
-
-  it("does not begin capture on mount — it waits for the Start tap", () => {
-    // Capture never auto-begins; the user must tap Start (parity across
-    // SDKs), so onStartCapture does not fire on mount.
-    const onStartCapture = vi.fn();
-    render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-        onStartCapture={onStartCapture}
-      />,
-    );
-    expect(onStartCapture).not.toHaveBeenCalled();
-  });
-
-  // NOTE: the legacy `overlayState` / `captureProgress` prop-driven tests
-  // were removed in Phase 3 of the per-frame migration. The capture
-  // screen now owns its overlay state internally (derived from the
-  // analyzer's per-frame UseSmileIDScanState), so there's no external prop to
-  // pin against. Phase 4 follow-up re-authors these as analyzer-driven
-  // tests that feed synthetic UseSmileIDScanState transitions through a mock
-  // analyzer + frame stream.
-
-  it("forwards the back tap to onBack when the back button is supplied", () => {
-    const onBack = vi.fn();
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-        onBack={onBack}
-      />,
-    );
-    const back = findByTestID(root, "si_capture_back_button");
-    expect(back).not.toBeNull();
-    act(() => {
-      (back!.props.onClick as () => void)();
-    });
-    expect(onBack).toHaveBeenCalledTimes(1);
-  });
-
-  it("omits the back button when onBack isn't supplied", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    expect(findByTestID(root, "si_capture_back_button")).toBeNull();
-  });
-
-  it("forces light mode on the back button, start button, and attribution", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-        onBack={() => {}}
-      />,
-    );
-    expect(
-      findByTestID(root, "si_capture_back_button")!.props.forceLightMode,
-    ).toBe(true);
-    expect(
-      findByTestID(root, "si_capture_start_button")!.props.forceLightMode,
-    ).toBe(true);
-    // Attribution renders the SVG with accessibilityLabel "Powered by Smile ID".
-    expect(
-      root.findAllByProps({ accessibilityLabel: "Powered by Smile ID" })[0],
-    ).toBeTruthy();
-  });
-
-  // Removed in Phase 3 — feedback text is now driven by the analyzer's
-  // UseSmileIDScanState rather than a partner-supplied overlayState prop. Phase 4
-  // re-authors this against a mock analyzer that yields a synthetic
-  // "found + feedback=si_capture_low_light" result through the
-  // frame stream.
-
-  it("hides attribution when showAttribution is false", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-        showAttribution={false}
-      />,
-    );
-    expect(
-      root.findAllByProps({ accessibilityLabel: "Powered by Smile ID" }),
-    ).toHaveLength(0);
-  });
-
-  it("forwards onStartCapture from a slot button tapped during INSTRUCTION", () => {
-    // The Start Capture button begins the analyzer pipeline. During
-    // INSTRUCTION (the only state where the slot renders), tapping
-    // the partner-supplied control must forward through to
-    // `onStartCapture` so the orchestrator can advance the flow.
-    const onStartCapture = vi.fn();
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-        onStartCapture={onStartCapture}
-        startButton={({ onClick }) => (
-          <Pressable testID="si_custom_start" onPress={onClick}>
-            <Text>Go</Text>
-          </Pressable>
-        )}
-      />,
-    );
-
-    act(() => {
-      (findByTestID(root, "si_custom_start")!.props.onPress as () => void)();
-    });
-    expect(onStartCapture).toHaveBeenCalledTimes(1);
-  });
-
-  it("renders a partner-supplied start button slot in INSTRUCTION state", () => {
-    const onStartCapture = vi.fn();
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-        onStartCapture={onStartCapture}
-        startButton={({ onClick, enabled }) => (
-          <Pressable
-            testID="si_custom_start"
-            onPress={onClick}
-            accessibilityState={{ disabled: !enabled }}
-          >
-            <Text>Go</Text>
-          </Pressable>
-        )}
-      />,
-    );
-    const slot = findByTestID(root, "si_custom_start");
-    expect(slot).not.toBeNull();
-    // Slot only renders during INSTRUCTION, where the analyzer
-    // hasn't started yet — `enabled` propagates as true.
-    expect(slot!.props.accessibilityState.disabled).toBe(false);
-    // Default start button must NOT also render — concrete scenario:
-    // a future refactor that double-renders both would silently stack.
-    expect(findByTestID(root, "si_capture_start_button")).toBeNull();
-  });
-
-  it("primes the guidance with the standard instruction before the first frame", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    const text = findByTestID(root, "si_capture_feedback_text");
-    // Pre-capture shows the press-Start instruction — the visible
-    // Start Capture button is the next action.
-    expect(collectText(text!)).toBe(enStrings.si_start_capture_instruction);
-  });
-
-  it("primes the guidance with the press-Start copy under Enhanced Smart Selfie too", () => {
-    // The ESS head-turn primer belongs to the scanning Initial state;
-    // pre-capture shows the press-Start instruction in both modes.
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-        enableEnhancedLiveness
-      />,
-    );
-    const text = findByTestID(root, "si_capture_feedback_text");
-    expect(collectText(text!)).toBe(enStrings.si_start_capture_instruction);
-  });
-
-  it("engages the brightness hook on mount", async () => {
-    render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    // The hook awaits getBrightness before issuing setBrightness.
-    // Two microtask flushes drain the chain.
-    await act(async () => {
-      await Promise.resolve();
-      await Promise.resolve();
-    });
-    expect(mockedGetBrightness).toHaveBeenCalledTimes(1);
-    expect(mockedSetBrightness).toHaveBeenCalledWith(1);
-  });
-
-  it("asks for dark status-bar content, matching the white capture scrim", () => {
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    expect(root.findAllByType(StatusBar)[0]!.props.barStyle).toBe(
-      "dark-content",
-    );
-  });
-
-  it("renders a translucent status bar so the preview is edge-to-edge", () => {
-    // Translucent status bar = full-bleed window = full-screen oval reference.
-    const { root } = render(
-      <UseSmileIDCaptureScreen
-        analyzer={fakeAnalyzer}
-        captureType={CaptureType.selfie}
-      />,
-    );
-    const statusBar = root.findAllByType(StatusBar)[0];
-    expect(statusBar).toBeTruthy();
-    expect(statusBar!.props.translucent).toBe(true);
-  });
-
-  it("drops capture events accumulated before an unsatisfied reset", async () => {
-    // Regression: events accumulated before an `unsatisfied` reset are stale
-    // and must not reach the submission set — only post-reset events should.
-    const onCaptureComplete = vi.fn();
-    let resolveFlush!: () => void;
-    const analyzer = makeFakeAnalyzer();
-    // flush() gates onCaptureComplete; resolve it manually to control timing.
-    vi.mocked(analyzer.flush).mockReturnValue(
-      new Promise<void>((resolve) => {
-        resolveFlush = resolve;
-      }),
-    );
-
-    // Reset so the assertion below proves THIS render registered the
-    // callback, not a leftover from an earlier test.
-    capturedOnResult = null;
-    render(
-      <UseSmileIDCaptureScreen
-        analyzer={analyzer}
-        captureType={CaptureType.selfie}
-        onCaptureComplete={onCaptureComplete}
-      />,
-    );
-    expect(capturedOnResult).not.toBeNull();
-    const emit = (result: FaceScanResult) => {
-      act(() => {
-        capturedOnResult!(result);
-      });
-    };
-
-    const output = { faces: [], brightness: 0 };
-    const event = (
-      kind: CaptureReadyEvent["kind"],
-      captureIndex: number,
-    ): CaptureReadyEvent => ({
-      kind,
-      captureIndex,
-      url: `file://${kind}-${captureIndex}`,
-    });
-
-    const staleSelfie = event(CaptureReadyEventKind.Selfie, 0);
-    const staleLiveness = event(CaptureReadyEventKind.Liveness, 0);
-    const freshSelfie = event(CaptureReadyEventKind.Selfie, 1);
-    const freshLiveness = event(CaptureReadyEventKind.Liveness, 1);
-
-    // Stale events → unsatisfied reset (drops them) → fresh events → finished.
-    emit({
-      output,
-      state: { type: UseSmileIDScanStateType.Found },
-      capturedEvents: [staleSelfie, staleLiveness],
-    });
-    emit({
-      output,
-      state: { type: UseSmileIDScanStateType.Unsatisfied },
-      capturedEvents: [],
-    });
-    emit({
-      output,
-      state: { type: UseSmileIDScanStateType.Found },
-      capturedEvents: [freshSelfie, freshLiveness],
-    });
-    emit({
-      output,
-      state: { type: UseSmileIDScanStateType.Finished },
-      capturedEvents: [],
-    });
-
-    await act(async () => {
-      resolveFlush();
-      await Promise.resolve();
-      await Promise.resolve();
-    });
-
-    expect(onCaptureComplete).toHaveBeenCalledTimes(1);
-    // Only the post-reset events survive — the stale ones were cleared.
-    // The capture telemetry (duration + retries) travels as a second argument;
-    // the retry count reflects the one unsatisfied reset observed above.
-    expect(onCaptureComplete).toHaveBeenCalledWith(
-      [freshSelfie, freshLiveness],
-      expect.objectContaining({ retries: 1 }),
-    );
-  });
-
-  it("replays the shared selfie scenario to a full capture completion", async () => {
-    // Drives the capture gap headlessly through the frame stream's onResult
-    // seam: the shared scenario replayed to `finished` must reach
-    // onCaptureComplete with the scripted selfie + liveness events.
-    const onCaptureComplete = vi.fn();
-    const analyzer = makeFakeAnalyzer();
-    capturedOnResult = null;
-    render(
-      <UseSmileIDCaptureScreen
-        analyzer={analyzer}
-        captureType={CaptureType.selfie}
-        onCaptureComplete={onCaptureComplete}
-      />,
-    );
-    expect(capturedOnResult).not.toBeNull();
-
-    // Consume the real shared scenario (not a hand-written copy) so a drift in
-    // the canonical script is caught here rather than silently diverging.
-    const scenarioDir = dirname(import.meta.url.replace(/^file:\/\//, ""));
-    const scenario = parseScriptedScenario(
-      JSON.parse(
-        readFileSync(
-          join(
-            scenarioDir,
-            "../../../../../e2e/scenarios/selfie-happy-path.json",
-          ),
-          "utf8",
-        ),
-      ),
-    );
-    for (const result of scriptedFaceScanResults(scenario, {
-      livenessCount: 2,
-    })) {
-      act(() => {
-        capturedOnResult!(result);
-      });
-    }
-    await act(async () => {
-      await Promise.resolve();
-      await Promise.resolve();
-    });
-
-    expect(onCaptureComplete).toHaveBeenCalledTimes(1);
-    const events = onCaptureComplete.mock.calls[0][0] as CaptureReadyEvent[];
-    expect(
-      events.filter((e) => e.kind === CaptureReadyEventKind.Selfie),
-    ).toHaveLength(1);
-    expect(
-      events.filter((e) => e.kind === CaptureReadyEventKind.Liveness),
-    ).toHaveLength(2);
-  });
-});
-
-/**
- * Session-boundary debouncer regression, exercised on
- * `UseSmileIDFeedbackDebouncer` directly because the route harness
- * cannot drive multi-step scan-state sequences. Mirrors the capture
- * screen's frame-result callback: `isSessionBoundary` decides when to
- * `reset()` + `seed()`.
- */
-describe("session-boundary epoch reset — debouncer regression", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("re-emits the smile key after an unsatisfied reset clears the debouncer", () => {
-    const emitted: string[] = [];
-    const debouncer = new UseSmileIDFeedbackDebouncer<string>({
-      emit: (value) => emitted.push(value),
-      delayMs: UseSmileIDMotion.feedbackDebounce,
-      isImmediate: () => false,
-    });
-
-    let previousScanState: UseSmileIDScanState | null = null;
-    const processTransition = (
-      nextScanState: UseSmileIDScanState,
-      nextFeedbackKey: string,
-    ) => {
-      const boundary =
-        previousScanState !== null &&
-        isSessionBoundary(previousScanState, nextScanState);
-      previousScanState = nextScanState;
-      if (boundary) {
-        debouncer.reset();
-        debouncer.seed(nextFeedbackKey);
-      } else {
-        debouncer.publish(nextFeedbackKey);
-      }
-    };
-
-    // found — smile key settles after the debounce window.
-    processTransition(
-      { type: UseSmileIDScanStateType.Found, feedback: "si_capture_smile" },
-      "si_capture_smile",
-    );
-    vi.advanceTimersByTime(UseSmileIDMotion.feedbackDebounce);
-    expect(emitted).toEqual(["si_capture_smile"]);
-
-    // Entering unsatisfied is not a boundary — no reset.
-    processTransition(
-      { type: UseSmileIDScanStateType.Unsatisfied },
-      "si_selfie_capture_unsatisfied",
-    );
-    vi.advanceTimersByTime(UseSmileIDMotion.feedbackDebounce);
-    expect(emitted).toEqual([
-      "si_capture_smile",
-      "si_selfie_capture_unsatisfied",
-    ]);
-
-    // Leaving unsatisfied is a boundary — without the reset the repeated
-    // smile key would be suppressed as a duplicate.
-    processTransition(
-      { type: UseSmileIDScanStateType.Found, feedback: "si_capture_smile" },
-      "si_capture_smile",
-    );
-    // seed() emits synchronously; no timer advance needed.
-    expect(emitted).toEqual([
-      "si_capture_smile",
-      "si_selfie_capture_unsatisfied",
-      "si_capture_smile",
-    ]);
-  });
-
-  // Document capture has no Start button, so a scan timeout has to leave the
-  // user a way forward — the sibling SDKs surface the manual shutter as the
-  // recovery affordance (their shared scan state sets `showCaptureButton` on
-  // the timeout state). Without these, a timed-out flow is a dead end: only
-  // Back and ✕ remain.
-  describe("document capture timeout recovery", () => {
-    function renderDocumentScreen(props: {
-      readonly captureMode: ReturnType<typeof DocumentCaptureMode.AutoCapture>;
-      readonly allowGalleryUpload?: boolean;
-    }) {
-      const tree = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.document}
-          captureMode={props.captureMode}
-          allowGalleryUpload={props.allowGalleryUpload ?? true}
-        />,
-      );
-      // The overlay and its controls only mount once the canvas is measured;
-      // `onLayout` never fires under the test renderer, so drive it (landscape,
-      // as a document capture screen is).
-      act(() => {
-        findByTestID(tree.root, "si_capture_screen")!.props.onLayout({
-          nativeEvent: { layout: { width: 800, height: 400 } },
-        });
-      });
-      return tree;
-    }
-
-    function emitTimeout() {
-      expect(capturedOnResult).not.toBeNull();
-      act(() => {
-        capturedOnResult!({
-          output: { faces: [], brightness: 0 },
-          state: { type: UseSmileIDScanStateType.Timeout },
-          capturedEvents: [],
-        });
-      });
-    }
-
-    it("offers the manual shutter after a timeout, in every capture mode", () => {
-      const { root } = renderDocumentScreen({
-        captureMode: DocumentCaptureMode.AutoCapture,
-      });
-
-      emitTimeout();
-
-      expect(findByTestID(root, "si_document_manual_shutter")).not.toBeNull();
-    });
-
-    it("keeps the gallery button available after a timeout", () => {
-      const { root } = renderDocumentScreen({
-        captureMode: DocumentCaptureMode.AutoCaptureWithManualFallback({
-          activateManualAfterMs: 3000,
-        }),
-      });
-
-      emitTimeout();
-
-      expect(findByTestID(root, "si_document_gallery_upload")).not.toBeNull();
-    });
-
-    it("leaves the manual shutter usable after a timeout", () => {
-      const { root } = renderDocumentScreen({
-        captureMode: DocumentCaptureMode.ManualCapture,
-      });
-
-      emitTimeout();
-
-      const shutter = findByTestID(root, "si_document_manual_shutter");
-      expect(shutter).not.toBeNull();
-      // The timeout must not latch the one-shot delivery gate, or the button
-      // renders but does nothing.
-      act(() => {
-        shutter!.props.onPress();
-      });
-      expect(mockedTakePhoto).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("selfie capture timeout recovery", () => {
-    function renderSelfieScreen() {
-      return render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-        />,
-      );
-    }
-
-    function startCapture(root: ReactTestInstance) {
-      act(() => {
-        findByTestID(root, "si_capture_start_button")!.props.onClick();
-      });
-    }
-
-    function emit(state: UseSmileIDScanState) {
-      expect(capturedOnResult).not.toBeNull();
-      act(() => {
-        capturedOnResult!({
-          output: { faces: [], brightness: 0 },
-          state,
-          capturedEvents: [],
-        });
-      });
-    }
-
-    it("offers Start again after a timeout", () => {
-      const { root } = renderSelfieScreen();
-      startCapture(root);
-
-      emit({ type: UseSmileIDScanStateType.Timeout });
-
-      const start = findByTestID(root, "si_capture_start_button");
-      expect(start).not.toBeNull();
-      expect(start!.props.enabled).toBe(true);
-    });
-
-    it("resets the native session when Start is tapped after a timeout", async () => {
-      const { root } = renderSelfieScreen();
-      startCapture(root);
-      emit({ type: UseSmileIDScanStateType.Timeout });
-      fakeAnalyzer.reset.mockClear();
-
-      startCapture(root);
-      await act(async () => {
-        await Promise.resolve();
-      });
-
-      // The native session is terminal after a timeout — without a reset the
-      // first retry frame re-reports Timeout and re-latches the error.
-      expect(fakeAnalyzer.reset).toHaveBeenCalledTimes(1);
-    });
-
-    it("restarts the session when Start is tapped after a timeout", () => {
-      const onStartCapture = vi.fn();
-      const { root } = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-          onStartCapture={onStartCapture}
-        />,
-      );
-      startCapture(root);
-      emit({ type: UseSmileIDScanStateType.Timeout });
-
-      startCapture(root);
-
-      expect(onStartCapture).toHaveBeenCalledTimes(2);
-    });
-
-    it("still delivers a capture that completes on the retry", async () => {
-      const onCaptureComplete = vi.fn();
-      const { root } = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-          onCaptureComplete={onCaptureComplete}
-        />,
-      );
-      startCapture(root);
-      emit({ type: UseSmileIDScanStateType.Timeout });
-      startCapture(root);
-
-      emit({ type: UseSmileIDScanStateType.Finished });
-      await act(async () => {
-        await Promise.resolve();
-        await Promise.resolve();
-      });
-
-      expect(onCaptureComplete).toHaveBeenCalledTimes(1);
-    });
-
-    it("drops a capture that lands after the timeout was already reported", async () => {
-      const onCaptureComplete = vi.fn();
-      const onCaptureTimeout = vi.fn();
-      const { root } = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-          onCaptureComplete={onCaptureComplete}
-          onCaptureTimeout={onCaptureTimeout}
-        />,
-      );
-      startCapture(root);
-
-      emit({ type: UseSmileIDScanStateType.Timeout });
-      emit({ type: UseSmileIDScanStateType.Finished });
-      await act(async () => {
-        await Promise.resolve();
-        await Promise.resolve();
-      });
-
-      expect(onCaptureTimeout).toHaveBeenCalledTimes(1);
-      expect(onCaptureComplete).not.toHaveBeenCalled();
-    });
-
-    it("does not pad the retry with frames banked before the timeout", async () => {
-      const onCaptureComplete = vi.fn();
-      const { root } = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-          onCaptureComplete={onCaptureComplete}
-        />,
-      );
-      startCapture(root);
-      act(() => {
-        capturedOnResult!({
-          output: { faces: [], brightness: 0 },
-          state: { type: UseSmileIDScanStateType.Found },
-          capturedEvents: [
-            {
-              kind: CaptureReadyEventKind.Liveness,
-              captureIndex: 0,
-              url: "file:///stale.jpg",
-            },
-          ] as CaptureReadyEvent[],
-        });
-      });
-      emit({ type: UseSmileIDScanStateType.Timeout });
-
-      startCapture(root);
-      act(() => {
-        capturedOnResult!({
-          output: { faces: [], brightness: 0 },
-          state: { type: UseSmileIDScanStateType.Found },
-          capturedEvents: [
-            {
-              kind: CaptureReadyEventKind.Selfie,
-              captureIndex: 0,
-              url: "file:///fresh.jpg",
-            },
-          ] as CaptureReadyEvent[],
-        });
-      });
-      emit({ type: UseSmileIDScanStateType.Finished });
-      await act(async () => {
-        await Promise.resolve();
-        await Promise.resolve();
-      });
-
-      expect(onCaptureComplete).toHaveBeenCalledTimes(1);
-      const [delivered] = onCaptureComplete.mock.calls[0] as [
-        readonly CaptureReadyEvent[],
-      ];
-      expect(delivered.map((event) => event.url)).toEqual([
-        "file:///fresh.jpg",
-      ]);
-    });
-
-    it("reports the timeout to the partner exactly once", () => {
-      const onCaptureTimeout = vi.fn();
-      const { root } = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-          onCaptureTimeout={onCaptureTimeout}
-        />,
-      );
-      startCapture(root);
-
-      emit({ type: UseSmileIDScanStateType.Timeout });
-      emit({ type: UseSmileIDScanStateType.Timeout });
-
-      expect(onCaptureTimeout).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("no camera frames at all", () => {
-    beforeEach(() => {
-      vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-
-    function renderAndStart() {
-      const tree = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-        />,
-      );
-      act(() => {
-        findByTestID(tree.root, "si_capture_start_button")!.props.onClick();
-      });
-      return tree;
-    }
-
-    function elapseFirstFrameWait() {
-      act(() => {
-        vi.advanceTimersByTime(10_000);
-      });
-    }
-
-    it("names the cause instead of sitting on the initial instruction", () => {
-      const { root } = renderAndStart();
-
-      elapseFirstFrameWait();
-
-      expect(collectText(findByTestID(root, "si_capture_feedback_text")!)).toBe(
-        enStrings.si_capture_camera_unavailable,
-      );
-    });
-
-    it("leaves the user a way to retry", () => {
-      const { root } = renderAndStart();
-
-      elapseFirstFrameWait();
-
-      const start = findByTestID(root, "si_capture_start_button");
-      expect(start).not.toBeNull();
-      expect(start!.props.enabled).toBe(true);
-    });
-
-    it("reports a terminal timeout so the flow is not left waiting", () => {
-      const onCaptureTimeout = vi.fn();
-      const tree = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-          onCaptureTimeout={onCaptureTimeout}
-        />,
-      );
-      act(() => {
-        findByTestID(tree.root, "si_capture_start_button")!.props.onClick();
-      });
-
-      elapseFirstFrameWait();
-
-      expect(onCaptureTimeout).toHaveBeenCalledTimes(1);
-    });
-
-    it("drops the stall copy once a frame finally arrives", () => {
-      const { root } = renderAndStart();
-      elapseFirstFrameWait();
-      expect(collectText(findByTestID(root, "si_capture_feedback_text")!)).toBe(
-        enStrings.si_capture_camera_unavailable,
-      );
-
-      act(() => {
-        capturedOnResult!({
-          output: { faces: [], brightness: 0 },
-          state: { type: UseSmileIDScanStateType.Initial },
-          capturedEvents: [],
-        });
-      });
-
-      expect(
-        collectText(findByTestID(root, "si_capture_feedback_text")!),
-      ).not.toBe(enStrings.si_capture_camera_unavailable);
-    });
-
-    it("still fires when the partner passes an inline callback", () => {
-      const onCaptureTimeout = vi.fn();
-      const screen = (
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-          onCaptureTimeout={(state) => onCaptureTimeout(state)}
-        />
-      );
-      const tree = render(screen);
-      act(() => {
-        findByTestID(tree.root, "si_capture_start_button")!.props.onClick();
-      });
-
-      for (let step = 0; step < 4; step += 1) {
-        act(() => {
-          tree.update(
-            <UseSmileIDCaptureScreen
-              analyzer={fakeAnalyzer}
-              captureType={CaptureType.selfie}
-              onCaptureTimeout={(state) => onCaptureTimeout(state)}
-            />,
-          );
-        });
-        act(() => {
-          vi.advanceTimersByTime(3_000);
-        });
-      }
-
-      expect(onCaptureTimeout).toHaveBeenCalledTimes(1);
-    });
-
-    it("stays quiet once a frame has been analyzed", () => {
-      const onCaptureTimeout = vi.fn();
-      const tree = render(
-        <UseSmileIDCaptureScreen
-          analyzer={fakeAnalyzer}
-          captureType={CaptureType.selfie}
-          onCaptureTimeout={onCaptureTimeout}
-        />,
-      );
-      act(() => {
-        findByTestID(tree.root, "si_capture_start_button")!.props.onClick();
-      });
-      act(() => {
-        capturedOnResult!({
-          output: { faces: [], brightness: 0 },
-          state: { type: UseSmileIDScanStateType.Initial },
-          capturedEvents: [],
-        });
-      });
-
-      elapseFirstFrameWait();
-
-      expect(onCaptureTimeout).not.toHaveBeenCalled();
-      expect(
-        collectText(findByTestID(tree.root, "si_capture_feedback_text")!),
-      ).not.toBe(enStrings.si_capture_camera_unavailable);
-    });
-  });
-});