@smileid/usesmileid 12.0.2 → 12.1.1

package/src/__tests__/snapshots/screens_structural.test.tsx

@@ -1,230 +0,0 @@
-import { describe, it, expect } from "vitest";
-import * as React from "react";
-import { View } from "react-native";
-import { act, create as createRenderer } from "react-test-renderer";
-import { CaptureType } from "../../core/models/ml_config";
-import { UseSmileIDCaptureContent } from "../../presentation/components/use_smile_id_capture_content";
-import type { UseSmileIDCaptureContentState } from "../../presentation/components/use_smile_id_capture_content";
-import { UseSmileIDConsentScreen } from "../../presentation/screen/use_smile_id_consent_screen";
-import { UseSmileIDDocumentBackInstructions } from "../../presentation/screen/use_smile_id_document_back_instructions";
-import { UseSmileIDDocumentPreviewScreen } from "../../presentation/screen/use_smile_id_document_preview_screen";
-import { UseSmileIDInstructionsScreen } from "../../presentation/screen/use_smile_id_instructions_screen";
-import { UseSmileIDPreviewScreen } from "../../presentation/screen/use_smile_id_preview_screen";
-import { UseSmileIDProcessingScreen } from "../../presentation/screen/use_smile_id_processing_screen";
-import { UseSmileIDFaceOverlay } from "../../presentation/components/use_smile_id_face_overlay";
-import { UseSmileIDDocumentOverlay } from "../../presentation/components/use_smile_id_document_overlay";
-import {
-  OVERLAY_STATE_COUNT,
-  UseSmileIDOverlayState,
-} from "../../presentation/state/use_smile_id_overlay_state";
-
-/**
- * Structural snapshots: pin the rendered element tree, not pixels (pixels are
- * the Detox lane's job). Keys follow the `<flow>/<screen>/<state>` contract.
- */
-
-function render(element: React.ReactElement) {
-  let tree!: ReturnType<typeof createRenderer>;
-  act(() => {
-    tree = createRenderer(element);
-  });
-  return tree;
-}
-
-const CONTAINER = { containerWidth: 390, containerHeight: 520 } as const;
-
-const DOCUMENT_STATES = Object.values(UseSmileIDOverlayState).filter((s) =>
-  s.startsWith("DOCUMENT_"),
-);
-const FACE_STATES = Object.values(UseSmileIDOverlayState).filter(
-  (s) => !s.startsWith("DOCUMENT_"),
-);
-
-describe("structural snapshots", () => {
-  it("pins the overlay state inventory", () => {
-    expect(FACE_STATES.length + DOCUMENT_STATES.length).toBe(
-      OVERLAY_STATE_COUNT,
-    );
-  });
-
-  describe("selfie/instructions", () => {
-    it("selfie/instructions/default", () => {
-      const tree = render(
-        <UseSmileIDInstructionsScreen
-          onBack={() => {}}
-          onContinue={() => {}}
-        />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  describe("selfie/capture overlay", () => {
-    it.each(FACE_STATES)("selfie/capture/%s", (state) => {
-      const tree = render(
-        <UseSmileIDFaceOverlay state={state} progress={0.5} {...CONTAINER} />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  describe("document/capture overlay", () => {
-    it.each(DOCUMENT_STATES)("document/capture/%s", (state) => {
-      const tree = render(
-        <UseSmileIDDocumentOverlay state={state} {...CONTAINER} />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  describe("consent", () => {
-    it("consent/default", () => {
-      const tree = render(
-        <UseSmileIDConsentScreen
-          partnerName="Acme Bank"
-          partnerPrivacyPolicyUrl="https://usesmileid.com/privacy"
-          onAllow={() => {}}
-          onDeny={() => {}}
-        />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  describe("document/back_instructions", () => {
-    it("document/back_instructions/default", () => {
-      const tree = render(
-        <UseSmileIDDocumentBackInstructions
-          documentTypeDisplayName="National ID"
-          onCaptureBack={() => {}}
-          allowSkip
-          onSkip={() => {}}
-          onBack={() => {}}
-        />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  describe("document/preview", () => {
-    it("document/preview/default", () => {
-      const tree = render(
-        <UseSmileIDDocumentPreviewScreen
-          documentAspectRatio={1.586}
-          onAccept={() => {}}
-          onReject={() => {}}
-          onClose={() => {}}
-        />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  // Composed capture screen: camera slot + overlay + feedback + controls.
-  function renderCaptureContent(
-    overrides: Partial<UseSmileIDCaptureContentState>,
-  ) {
-    return render(
-      <UseSmileIDCaptureContent
-        state={{
-          captureType: CaptureType.selfie,
-          overlayState: UseSmileIDOverlayState.INSTRUCTION,
-          enableEnhancedLiveness: false,
-          animationDirection: null,
-          poseMatched: false,
-          feedbackKey: null,
-          showCaptureButton: false,
-          ...overrides,
-        }}
-        captureProgress={0}
-        cameraPreview={<View testID="camera-slot" />}
-        onStartCapture={() => {}}
-        startCaptureEnabled={true}
-        showAttribution={true}
-        onManualShutter={() => {}}
-        onGalleryUpload={() => {}}
-      />,
-    );
-  }
-
-  describe("selfie/capture content", () => {
-    it("selfie/capture/start_button", () => {
-      const tree = renderCaptureContent({
-        overlayState: UseSmileIDOverlayState.INSTRUCTION,
-        feedbackKey: "si_start_capture_instruction",
-        showCaptureButton: true,
-      });
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  describe("document/capture content", () => {
-    const DOCUMENT_VARIANTS: ReadonlyArray<
-      [string, Partial<UseSmileIDCaptureContentState>]
-    > = [
-      ["card_front", { documentTypeKind: "genericDocument" }],
-      ["card_back", { documentTypeKind: "genericDocument", isBackSide: true }],
-      // TD3 passport data page ratio (125×88 mm).
-      ["passport", { documentTypeKind: "passport", knownIdAspectRatio: 1.42 }],
-      ["green_book", { documentTypeKind: "southAfricaGreenBook" }],
-    ];
-
-    it.each(DOCUMENT_VARIANTS)("document/capture/%s", (_name, overrides) => {
-      const tree = renderCaptureContent({
-        captureType: CaptureType.document,
-        overlayState: UseSmileIDOverlayState.IDLE,
-        knownIdAspectRatio: 1.586,
-        showGalleryUpload: true,
-        ...overrides,
-      });
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-
-    it("document/capture/manual_shutter", () => {
-      const tree = renderCaptureContent({
-        captureType: CaptureType.document,
-        overlayState: UseSmileIDOverlayState.DOCUMENT_TOO_FAR,
-        feedbackKey: "si_document_too_far",
-        documentTypeKind: "genericDocument",
-        knownIdAspectRatio: 1.586,
-        showManualShutter: true,
-        showGalleryUpload: true,
-      });
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  describe("selfie/preview", () => {
-    it("selfie/preview/default", () => {
-      const tree = render(<UseSmileIDPreviewScreen />);
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-
-  describe("selfie/processing", () => {
-    it("selfie/processing/loading", () => {
-      const tree = render(
-        <UseSmileIDProcessingScreen state={{ kind: "loading" }} />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-
-    it("selfie/processing/success", () => {
-      const tree = render(
-        <UseSmileIDProcessingScreen
-          state={{ kind: "success", message: "Verification submitted" }}
-        />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-
-    it("selfie/processing/failed", () => {
-      const tree = render(
-        <UseSmileIDProcessingScreen
-          state={{ kind: "failed", errorMessage: "Network unavailable" }}
-        />,
-      );
-      expect(tree.toJSON()).toMatchSnapshot();
-    });
-  });
-});

package/src/__tests__/theme.test.ts

@@ -1,156 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  defaultDarkTheme,
-  defaultLightTheme,
-} from "../presentation/theme/theme";
-
-const REQUIRED_COLOR_TOKENS = [
-  // Brand
-  "primary",
-  "primaryForeground",
-  "secondary",
-  "accent",
-  // Surfaces
-  "background",
-  "cardBackground",
-  "instructionCardBackground",
-  // Text
-  "titleText",
-  "cardText",
-  // Disabled / inactive
-  "disabledBackground",
-  "disabledForeground",
-  // Borders
-  "stroke",
-  // Semantic
-  "warningFill",
-  "warningIcon",
-  "warningStroke",
-  "successFill",
-  "successIcon",
-  // Capture overlay
-  "captureOverlayBackground",
-  "documentOverlayScrim",
-  "captureOverlayStroke",
-  "captureFeedbackBackground",
-  "captureFeedbackText",
-  "captureProgressIndicator",
-  // Oval
-  "ovalDefault",
-  "ovalActive",
-  "ovalWarning",
-  // Preview
-  "previewAcceptBackground",
-  "previewAcceptIcon",
-  "previewRejectBackground",
-  "previewRejectIcon",
-  // Branding
-  "smileIdYellow",
-  "offBlack",
-  "offWhite",
-] as const;
-
-const REQUIRED_TYPOGRAPHY_STYLES = [
-  "pageHeading",
-  "sectionHeading",
-  "subHeading",
-  "cardTitle",
-  "cardSubTitle",
-  "body",
-  "button",
-] as const;
-
-describe("theme defaults", () => {
-  it("exposes both light and dark variants with identical structure", () => {
-    expect(Object.keys(defaultLightTheme).sort()).toEqual(
-      Object.keys(defaultDarkTheme).sort(),
-    );
-    expect(Object.keys(defaultLightTheme.colors).sort()).toEqual(
-      Object.keys(defaultDarkTheme.colors).sort(),
-    );
-  });
-
-  it("uses the same typography / spacing / shape scale across variants", () => {
-    // Concrete scenario: a partner overrides `colors` only and keeps
-    // the SDK's typography. If a future change accidentally diverges
-    // the typography between light and dark, partners using mixed
-    // overrides would see inconsistent text sizes between themes.
-    expect(defaultDarkTheme.typography).toEqual(defaultLightTheme.typography);
-    expect(defaultDarkTheme.spacing).toEqual(defaultLightTheme.spacing);
-    expect(defaultDarkTheme.shapes).toEqual(defaultLightTheme.shapes);
-  });
-
-  it("emits canonical RGB or RGBA hex values for every documented colour token", () => {
-    // 6 hex digits = opaque, 8 hex digits = with alpha. Either is
-    // valid in React Native; reject anything else (named colours,
-    // rgba() strings) so partner-overridden palettes round-trip.
-    const HEX = /^#[0-9A-F]{6}([0-9A-F]{2})?$/i;
-    for (const [key, value] of Object.entries(defaultLightTheme.colors)) {
-      expect(value, `light.${key}`).toMatch(HEX);
-    }
-    for (const [key, value] of Object.entries(defaultDarkTheme.colors)) {
-      expect(value, `dark.${key}`).toMatch(HEX);
-    }
-  });
-
-  it("contains every documented colour token", () => {
-    // Concrete scenario: a future refactor drops a token (e.g.
-    // `captureOverlayStroke`) — capture screen would render with an
-    // undefined border colour. Pin every documented token here.
-    for (const token of REQUIRED_COLOR_TOKENS) {
-      expect(defaultLightTheme.colors).toHaveProperty(token);
-      expect(defaultDarkTheme.colors).toHaveProperty(token);
-    }
-  });
-
-  it("pins canonical brand colours", () => {
-    // Concrete scenario: drift in `primary` would mean a partner's
-    // RN app suddenly displays a different brand colour from one
-    // release to the next.
-    expect(defaultLightTheme.colors.primary).toBe("#151F72");
-    expect(defaultDarkTheme.colors.primary).toBe("#4D88FF");
-    expect(defaultLightTheme.colors.captureOverlayStroke).toBe("#151F72");
-    expect(defaultDarkTheme.colors.captureOverlayStroke).toBe("#4D88FF");
-  });
-
-  it("exposes the 7 canonical typography styles", () => {
-    for (const style of REQUIRED_TYPOGRAPHY_STYLES) {
-      expect(defaultLightTheme.typography).toHaveProperty(style);
-      const v = (defaultLightTheme.typography as Record<string, unknown>)[
-        style
-      ];
-      expect(v).toMatchObject({
-        fontSize: expect.any(Number),
-        lineHeight: expect.any(Number),
-        fontWeight: expect.any(String),
-      });
-    }
-  });
-
-  it("pins button radius to 32", () => {
-    // Concrete scenario: drift back to 8 would render rounded
-    // squares instead of pills — visible on every screen with
-    // a button.
-    expect(defaultLightTheme.shapes.buttonRadius).toBe(32);
-    expect(defaultDarkTheme.shapes.buttonRadius).toBe(32);
-  });
-
-  it("pins card radius to 12 across both themes", () => {
-    expect(defaultLightTheme.shapes.cardRadius).toBe(16);
-    expect(defaultDarkTheme.shapes.cardRadius).toBe(16);
-  });
-
-  it("pins canonical spacing scale (8 / 12 / 16 / 24 / 40)", () => {
-    // Concrete failure mode: if these drift, partner visual
-    // styling tied to the spacing scale degrades silently.
-    const expected = {
-      extraSmall: 8,
-      small: 12,
-      medium: 16,
-      large: 24,
-      extraLarge: 40,
-    };
-    expect(defaultLightTheme.spacing).toEqual(expected);
-    expect(defaultDarkTheme.spacing).toEqual(expected);
-  });
-});

package/src/camera/__tests__/camera_defaults.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CameraDefaults } from "../camera_defaults";
-
-describe("CameraDefaults", () => {
-  it("pins focus-indicator durations", () => {
-    expect(CameraDefaults.focusRunningDurationMs).toBe(600);
-    expect(CameraDefaults.focusSettledDurationMs).toBe(500);
-  });
-
-  it("pins the analysis-stream frame rate at 30 fps", () => {
-    // Concrete scenario: a refactor drifts the analysis fps to 15
-    // (motion-blurry head turns) or 60 (high-ISO noise from shorter
-    // per-frame exposure). 30 fps is the documented sweet spot for
-    // selfie / face-tracking ML pipelines. Pin it here.
-    expect(CameraDefaults.analysisTargetFps).toBe(30);
-  });
-
-  it("pins the analysis-stream resolution at 640×480", () => {
-    // Concrete scenario: a refactor bumps the analysis resolution to
-    // 720p+. Every analyzed frame is plane-copied and scanned while
-    // the frame-processor thread blocks, so per-frame latency scales
-    // linearly with pixel count — at 720p (3× the pixels) the camera
-    // pipeline visibly stutters. 640×480 is the scan sessions' tuned
-    // input size; the preview stream stays high-res independently.
-    expect(CameraDefaults.analysisTargetResolution.width).toBe(640);
-    expect(CameraDefaults.analysisTargetResolution.height).toBe(480);
-  });
-});

package/src/camera/__tests__/camera_lens.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CameraLens } from "../camera_lens";
-
-describe("CameraLens", () => {
-  it("exposes the two canonical lens values", () => {
-    expect(CameraLens.front).toBe("front");
-    expect(CameraLens.back).toBe("back");
-  });
-
-  it("values are the strings useCameraDevice expects as its position argument", () => {
-    // Concrete scenario: a future rename to capitalised 'Front' would
-    // silently break `useCameraDevice(CameraLens.front)` because
-    // vision-camera's position type is the lowercase string union
-    // `'front' | 'back' | 'external'`. Pin the wire format here.
-    expect(CameraLens.front).toBe("front");
-    expect(CameraLens.back).toBe("back");
-  });
-});

package/src/camera/__tests__/camera_permissions.test.ts

@@ -1,72 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { Camera } from "react-native-vision-camera";
-import {
-  getCameraPermissionStatus,
-  requestCameraPermission,
-} from "../camera_permissions";
-
-// The shared setup mocks `react-native-vision-camera`; these are its
-// permission statics, re-armed per test.
-const getStatus = vi.mocked(Camera.getCameraPermissionStatus);
-const requestStatus = vi.mocked(Camera.requestCameraPermission);
-
-beforeEach(() => {
-  getStatus.mockReset();
-  requestStatus.mockReset();
-});
-
-describe("getCameraPermissionStatus", () => {
-  it("reports granted without prompting", async () => {
-    getStatus.mockReturnValue("granted");
-
-    await expect(getCameraPermissionStatus()).resolves.toBe("granted");
-    expect(requestStatus).not.toHaveBeenCalled();
-  });
-
-  it("normalises vision-camera's not-determined to undetermined", async () => {
-    getStatus.mockReturnValue("not-determined");
-
-    await expect(getCameraPermissionStatus()).resolves.toBe("undetermined");
-  });
-
-  it("reports denied as denied", async () => {
-    getStatus.mockReturnValue("denied");
-
-    await expect(getCameraPermissionStatus()).resolves.toBe("denied");
-  });
-
-  it("collapses restricted to denied so callers need only three branches", async () => {
-    getStatus.mockReturnValue("restricted");
-
-    await expect(getCameraPermissionStatus()).resolves.toBe("denied");
-  });
-});
-
-describe("requestCameraPermission", () => {
-  it("prompts and reports the granted outcome", async () => {
-    requestStatus.mockResolvedValue("granted");
-
-    await expect(requestCameraPermission()).resolves.toBe("granted");
-    expect(requestStatus).toHaveBeenCalledTimes(1);
-  });
-
-  it("reports a dismissed prompt as denied", async () => {
-    requestStatus.mockResolvedValue("denied");
-
-    await expect(requestCameraPermission()).resolves.toBe("denied");
-  });
-
-  it("maps a restricted device to denied rather than leaking the raw status", async () => {
-    requestStatus.mockResolvedValue("restricted");
-
-    await expect(requestCameraPermission()).resolves.toBe("denied");
-  });
-
-  it("never reports undetermined once the prompt has resolved granted", async () => {
-    requestStatus.mockResolvedValue("granted");
-
-    const status = await requestCameraPermission();
-
-    expect(status).not.toBe("undetermined");
-  });
-});

package/src/camera/__tests__/camera_system_focus.test.ts

@@ -1,173 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-/**
- * Tap-to-focus half of the camera orchestrator: the reticle state machine
- * (`running` → `success` → `unspecified`), the vision-camera `focus()` call
- * through the attached ref, and the fail-open behaviour on fixed-focus
- * devices. The lifecycle half lives in `use_smile_id_camera_system.test.ts`.
- */
-const { permissions, captureException } = vi.hoisted(() => ({
-  permissions: { getStatus: vi.fn(), request: vi.fn() },
-  captureException: vi.fn(),
-}));
-
-vi.mock("../camera_permissions", () => ({
-  getCameraPermissionStatus: permissions.getStatus,
-  requestCameraPermission: permissions.request,
-}));
-
-vi.mock("@smileid/usesmileid_bridge", async () => {
-  const actual = await vi.importActual<
-    typeof import("@smileid/usesmileid_bridge")
-  >("@smileid/usesmileid_bridge");
-  return {
-    ...actual,
-    UseSmileIDCrashReporting: {
-      ...actual.UseSmileIDCrashReporting,
-      captureException,
-    },
-  };
-});
-
-import type { Camera } from "react-native-vision-camera";
-import { CameraDefaults } from "../camera_defaults";
-import type { FocusState } from "../focus_state";
-import { UseSmileIDCameraSystem } from "../use_smile_id_camera_system";
-
-const POINT = { x: 0.25, y: 0.75 };
-
-function attachCamera(
-  system: UseSmileIDCameraSystem,
-  focus: (point: { x: number; y: number }) => Promise<void>,
-) {
-  const ref = { focus: vi.fn(focus) };
-  system.attachRef(ref as unknown as Camera);
-  return ref;
-}
-
-describe("UseSmileIDCameraSystem — tap to focus", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    permissions.getStatus.mockReset();
-    permissions.request.mockReset();
-    captureException.mockReset();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("drives the reticle through running → success → unspecified", async () => {
-    const system = new UseSmileIDCameraSystem();
-    const seen: FocusState[] = [];
-    system.subscribe((_state, focus) => seen.push(focus));
-
-    await system.tapToFocus(POINT);
-    expect(system.getFocusState()).toEqual({ kind: "running", point: POINT });
-
-    await vi.advanceTimersByTimeAsync(CameraDefaults.focusRunningDurationMs);
-    expect(system.getFocusState()).toEqual({ kind: "success", point: POINT });
-
-    await vi.advanceTimersByTimeAsync(CameraDefaults.focusSettledDurationMs);
-    expect(system.getFocusState()).toEqual({ kind: "unspecified" });
-
-    expect(seen.map((focus) => focus.kind)).toEqual([
-      "running",
-      "success",
-      "unspecified",
-    ]);
-  });
-
-  it("calls vision-camera focus() with the normalized point", async () => {
-    const system = new UseSmileIDCameraSystem();
-    const ref = attachCamera(system, async () => {});
-
-    await system.tapToFocus(POINT);
-
-    expect(ref.focus).toHaveBeenCalledWith({ x: 0.25, y: 0.75 });
-    expect(captureException).not.toHaveBeenCalled();
-  });
-
-  it("keeps the reticle moving when the lens rejects the focus request", async () => {
-    const system = new UseSmileIDCameraSystem();
-    const failure = new Error("fixed-focus front camera");
-    attachCamera(system, async () => {
-      throw failure;
-    });
-
-    await system.tapToFocus(POINT);
-
-    expect(captureException).toHaveBeenCalledWith(failure);
-    expect(system.getFocusState()).toEqual({ kind: "running", point: POINT });
-
-    await vi.advanceTimersByTimeAsync(CameraDefaults.focusRunningDurationMs);
-    expect(system.getFocusState().kind).toBe("success");
-  });
-
-  it("a second tap restarts the timers instead of stacking them", async () => {
-    const system = new UseSmileIDCameraSystem();
-    const secondPoint = { x: 0.9, y: 0.1 };
-
-    await system.tapToFocus(POINT);
-    await vi.advanceTimersByTimeAsync(
-      CameraDefaults.focusRunningDurationMs - 10,
-    );
-    await system.tapToFocus(secondPoint);
-
-    // The first tap's success timer was cleared — 10 ms in, still running.
-    await vi.advanceTimersByTimeAsync(10);
-    expect(system.getFocusState()).toEqual({
-      kind: "running",
-      point: secondPoint,
-    });
-
-    await vi.advanceTimersByTimeAsync(CameraDefaults.focusRunningDurationMs);
-    expect(system.getFocusState()).toEqual({
-      kind: "success",
-      point: secondPoint,
-    });
-  });
-
-  it("is a no-op after release(), and release() cancels pending reticle timers", async () => {
-    const system = new UseSmileIDCameraSystem();
-    const ref = attachCamera(system, async () => {});
-
-    await system.tapToFocus(POINT);
-    system.release();
-
-    await vi.advanceTimersByTimeAsync(
-      CameraDefaults.focusRunningDurationMs +
-        CameraDefaults.focusSettledDurationMs,
-    );
-    // The pending success/settled transitions were cancelled by release().
-    expect(system.getFocusState()).toEqual({ kind: "running", point: POINT });
-
-    ref.focus.mockClear();
-    await system.tapToFocus({ x: 0.5, y: 0.5 });
-    expect(ref.focus).not.toHaveBeenCalled();
-    expect(system.getFocusState()).toEqual({ kind: "running", point: POINT });
-  });
-
-  it("skips the native call when no camera ref is attached", async () => {
-    const system = new UseSmileIDCameraSystem();
-    system.attachRef(null);
-
-    await system.tapToFocus(POINT);
-
-    expect(captureException).not.toHaveBeenCalled();
-    await vi.advanceTimersByTimeAsync(CameraDefaults.focusRunningDurationMs);
-    expect(system.getFocusState().kind).toBe("success");
-  });
-
-  it("never lets a throwing subscriber break the dispatch chain", async () => {
-    const system = new UseSmileIDCameraSystem();
-    const healthy = vi.fn();
-    system.subscribe(() => {
-      throw new Error("partner overlay blew up");
-    });
-    system.subscribe(healthy);
-
-    await expect(system.tapToFocus(POINT)).resolves.toBeUndefined();
-    expect(healthy).toHaveBeenCalled();
-  });
-});