@smileid/usesmileid 12.0.1 → 12.1.0

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__/document_resize_target.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { computeDocumentResizeTarget } from "../document_resize_target";
-
-const MAX = 1600;
-
-describe("computeDocumentResizeTarget", () => {
-  it("clamps the longest edge of a landscape image to the width", () => {
-    // 12 MP landscape still (4032×3024) → longest edge is the width.
-    expect(computeDocumentResizeTarget(4032, 3024, MAX)).toEqual({
-      width: MAX,
-    });
-  });
-
-  it("clamps the longest edge of a portrait image to the height", () => {
-    // Portrait booklet/passport still (3024×4032) → longest edge is the height.
-    expect(computeDocumentResizeTarget(3024, 4032, MAX)).toEqual({
-      height: MAX,
-    });
-  });
-
-  it("clamps a square image on the width (w >= h tie-break)", () => {
-    expect(computeDocumentResizeTarget(2000, 2000, MAX)).toEqual({
-      width: MAX,
-    });
-  });
-
-  it("never upscales an image already within bounds", () => {
-    // Concrete scenario: the native auto-capture frame is ~640×480; an
-    // imported still that is already small must NOT be blown up to 1600 —
-    // that would add bytes and blur and diverge from the auto artifact.
-    expect(computeDocumentResizeTarget(640, 480, MAX)).toBeNull();
-  });
-
-  it("returns null when the longest edge is exactly the ceiling", () => {
-    expect(computeDocumentResizeTarget(MAX, 900, MAX)).toBeNull();
-    expect(computeDocumentResizeTarget(900, MAX, MAX)).toBeNull();
-  });
-
-  it("treats degenerate dimensions defensively (no resize)", () => {
-    expect(computeDocumentResizeTarget(0, 0, MAX)).toBeNull();
-    expect(computeDocumentResizeTarget(-100, 200, MAX)).toBeNull();
-    expect(computeDocumentResizeTarget(Number.NaN, 3000, MAX)).toBeNull();
-  });
-});

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

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { FocusStates, type FocusState } from "../focus_state";
-
-describe("FocusStates factory", () => {
-  it("produces an unspecified state with no point", () => {
-    const state = FocusStates.unspecified();
-    expect(state.kind).toBe("unspecified");
-    expect("point" in state).toBe(false);
-  });
-
-  it.each(["running", "success", "failure"] as const)(
-    "produces a %s state carrying the focus point",
-    (kind) => {
-      const point = { x: 0.4, y: 0.6 };
-      const state = FocusStates[kind](point);
-      expect(state.kind).toBe(kind);
-      // TS narrowing: `kind` is one of running/success/failure here,
-      // so `point` is in the union. Runtime check pins the contract.
-      if (state.kind !== "unspecified") {
-        expect(state.point).toEqual(point);
-      }
-    },
-  );
-
-  it("exhaustive switch over FocusState narrows correctly", () => {
-    // Concrete scenario: an orchestrator's reducer does
-    // `switch (state.kind)` to drive the focus reticle animation.
-    // A future variant added without updating the union would
-    // surface as a type error here (and a runtime fallthrough at
-    // partner sites). Pin the four-variant exhaustiveness.
-    const visit = (state: FocusState): string => {
-      switch (state.kind) {
-        case "unspecified":
-          return "idle";
-        case "running":
-          return `running@${state.point.x},${state.point.y}`;
-        case "success":
-          return `success@${state.point.x},${state.point.y}`;
-        case "failure":
-          return `failure@${state.point.x},${state.point.y}`;
-      }
-    };
-    expect(visit(FocusStates.unspecified())).toBe("idle");
-    expect(visit(FocusStates.running({ x: 0, y: 0 }))).toBe("running@0,0");
-    expect(visit(FocusStates.success({ x: 1, y: 0 }))).toBe("success@1,0");
-    expect(visit(FocusStates.failure({ x: 0, y: 1 }))).toBe("failure@0,1");
-  });
-});

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

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { orientationToDegrees } from "../orientation_degrees";
-
-/**
- * Pins the VisionCamera Orientation → degree mapping the native scan
- * sessions consume as device-orientation context. The native upright
- * validator gates capture on `0` (physically upright portrait), so a
- * wrong mapping here manifests as the capture flow permanently stuck
- * on "keep your device upright" guidance.
- */
-describe("orientationToDegrees", () => {
-  it("maps upright portrait to 0 — the only value the upright validator passes", () => {
-    expect(orientationToDegrees("portrait")).toBe(0);
-  });
-
-  it("maps the rotated orientations to their clockwise degrees", () => {
-    expect(orientationToDegrees("landscape-left")).toBe(90);
-    expect(orientationToDegrees("portrait-upside-down")).toBe(180);
-    expect(orientationToDegrees("landscape-right")).toBe(270);
-  });
-});

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

@@ -1,103 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-/**
- * Boundary characterization for `UseSmileIDCameraSystem`'s lifecycle state machine
- * (permission gating, running/streaming flags, lens config, listener fan-out). The
- * frame loop is a vision-camera worklet pinned separately by
- * `use_smile_id_frame_stream.test.ts`. Must hold byte-identically across any
- * camera-implementation swap.
- */
-const permissions = vi.hoisted(() => ({
-  getStatus: vi.fn(),
-  request: vi.fn(),
-}));
-
-vi.mock("../camera_permissions", () => ({
-  getCameraPermissionStatus: permissions.getStatus,
-  requestCameraPermission: permissions.request,
-}));
-
-import { CameraLens } from "../camera_lens";
-import { UseSmileIDCameraSystem } from "../use_smile_id_camera_system";
-
-describe("UseSmileIDCameraSystem — boundary characterization", () => {
-  beforeEach(() => {
-    permissions.getStatus.mockReset();
-    permissions.request.mockReset();
-  });
-
-  it("starts idle with the configured lens", () => {
-    const system = new UseSmileIDCameraSystem(CameraLens.back);
-    const state = system.getState();
-    expect(state.isCameraRunning).toBe(false);
-    expect(state.isStreaming).toBe(false);
-    expect(state.hasPermission).toBe(false);
-    expect(state.currentLens).toBe(CameraLens.back);
-  });
-
-  it("start() runs + streams when permission is already granted (no re-prompt)", async () => {
-    permissions.getStatus.mockResolvedValue("granted");
-    const system = new UseSmileIDCameraSystem();
-    await system.start();
-    const state = system.getState();
-    expect(state.isCameraRunning).toBe(true);
-    expect(state.isStreaming).toBe(true);
-    expect(state.hasPermission).toBe(true);
-    expect(permissions.request).not.toHaveBeenCalled();
-  });
-
-  it("start() prompts when undetermined, then runs on grant", async () => {
-    permissions.getStatus.mockResolvedValue("undetermined");
-    permissions.request.mockResolvedValue("granted");
-    const system = new UseSmileIDCameraSystem();
-    await system.start();
-    expect(permissions.request).toHaveBeenCalledTimes(1);
-    expect(system.getState().isCameraRunning).toBe(true);
-  });
-
-  it("start() stays off when permission is denied", async () => {
-    permissions.getStatus.mockResolvedValue("undetermined");
-    permissions.request.mockResolvedValue("denied");
-    const system = new UseSmileIDCameraSystem();
-    await system.start();
-    const state = system.getState();
-    expect(state.isCameraRunning).toBe(false);
-    expect(state.hasPermission).toBe(false);
-  });
-
-  it("start() after release() throws — a released system is unusable", async () => {
-    permissions.getStatus.mockResolvedValue("granted");
-    const system = new UseSmileIDCameraSystem();
-    system.release();
-    await expect(system.start()).rejects.toThrow(/after release/);
-  });
-
-  it("stop() pauses running + streaming without releasing (re-startable)", async () => {
-    permissions.getStatus.mockResolvedValue("granted");
-    const system = new UseSmileIDCameraSystem();
-    await system.start();
-    system.stop();
-    const state = system.getState();
-    expect(state.isCameraRunning).toBe(false);
-    expect(state.isStreaming).toBe(false);
-  });
-
-  it("configure() swaps the lens and notifies subscribers", () => {
-    const system = new UseSmileIDCameraSystem(CameraLens.front);
-    const seenLenses: CameraLens[] = [];
-    system.subscribe((state) => seenLenses.push(state.currentLens));
-    system.configure({ lens: CameraLens.back });
-    expect(system.getState().currentLens).toBe(CameraLens.back);
-    expect(seenLenses).toContain(CameraLens.back);
-  });
-
-  it("unsubscribe stops further notifications", async () => {
-    permissions.getStatus.mockResolvedValue("granted");
-    const system = new UseSmileIDCameraSystem();
-    const listener = vi.fn();
-    const unsubscribe = system.subscribe(listener);
-    unsubscribe();
-    await system.start();
-    expect(listener).not.toHaveBeenCalled();
-  });
-});