@smileid/usesmileid 12.0.2 → 12.1.0

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_preview.test.tsx

@@ -1,461 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import * as React from "react";
-import { create as createRenderer, act } from "react-test-renderer";
-import { Pressable, View } from "react-native";
-import * as VisionCamera from "react-native-vision-camera";
-import { FrameProcessorPluginNotRegisteredException } from "@smileid/usesmileid_bridge";
-
-import { UseSmileIDCameraPreview } from "../use_smile_id_camera_preview";
-import { UseSmileIDCameraSystem } from "../use_smile_id_camera_system";
-import { CameraLens } from "../camera_lens";
-import { CameraDefaults } from "../camera_defaults";
-import type { CameraSystemState } from "../camera_configuration";
-import type { FocusState } from "../focus_state";
-
-/**
- * Component-level tests for `<UseSmileIDCameraPreview>` — the seam
- * between the camera orchestrator and vision-camera. The native
- * bindings are mocked in `setup_react_native.ts`; these tests drive
- * the boundary the preview owns: ref attach/detach, subscription
- * fan-out, plugin initialisation + the missing-plugin error, the
- * frame-processor worklet body, layout-normalised tap-to-focus, and
- * the function-as-children overlay contract.
- */
-
-const mockedUseCameraDevice = vi.mocked(VisionCamera.useCameraDevice);
-const mockedUseCameraFormat = vi.mocked(VisionCamera.useCameraFormat);
-const mockedUseFrameProcessor = vi.mocked(VisionCamera.useFrameProcessor);
-const mockedInitPlugin = vi.mocked(
-  VisionCamera.VisionCameraProxy.initFrameProcessorPlugin,
-);
-
-type CameraDevice = ReturnType<typeof VisionCamera.useCameraDevice>;
-
-const fakeDevice = {
-  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 CameraDevice;
-
-function render(element: React.ReactElement) {
-  let tree!: ReturnType<typeof createRenderer>;
-  act(() => {
-    tree = createRenderer(element);
-  });
-  return tree;
-}
-
-type CameraProps = {
-  readonly isActive: boolean;
-  readonly fps: number;
-  readonly photo: boolean;
-  readonly device: unknown;
-  readonly outputOrientation: string;
-  readonly format?: unknown;
-  readonly frameProcessor?: unknown;
-  readonly onOutputOrientationChanged: (orientation: string) => void;
-};
-
-function cameraProps(root: ReturnType<typeof render>["root"]): CameraProps {
-  return root.findByType(VisionCamera.Camera).props as unknown as CameraProps;
-}
-
-function findCameras(root: ReturnType<typeof render>["root"]) {
-  return root.findAllByType(VisionCamera.Camera);
-}
-
-/** Drives `onLayout` on the preview's root `<View>` so taps normalise. */
-function layout(
-  root: ReturnType<typeof render>["root"],
-  width: number,
-  height: number,
-) {
-  const view = root.findAllByType(View)[0];
-  act(() => {
-    (
-      view.props as {
-        onLayout: (event: {
-          nativeEvent: { layout: { width: number; height: number } };
-        }) => void;
-      }
-    ).onLayout({ nativeEvent: { layout: { width, height } } });
-  });
-}
-
-function tap(
-  root: ReturnType<typeof render>["root"],
-  locationX: number,
-  locationY: number,
-) {
-  const pressable = root.findAllByType(Pressable)[0];
-  act(() => {
-    (
-      pressable.props as {
-        onPress: (event: {
-          nativeEvent: { locationX: number; locationY: number };
-        }) => void;
-      }
-    ).onPress({ nativeEvent: { locationX, locationY } });
-  });
-}
-
-describe("UseSmileIDCameraPreview", () => {
-  beforeEach(() => {
-    mockedUseCameraDevice.mockReset();
-    mockedUseCameraDevice.mockReturnValue(fakeDevice);
-    mockedUseCameraFormat.mockReset();
-    mockedUseCameraFormat.mockReturnValue(
-      undefined as unknown as ReturnType<typeof VisionCamera.useCameraFormat>,
-    );
-    mockedUseFrameProcessor.mockReset();
-    mockedUseFrameProcessor.mockImplementation(
-      (worklet) =>
-        worklet as unknown as ReturnType<typeof VisionCamera.useFrameProcessor>,
-    );
-    mockedInitPlugin.mockReset();
-    mockedInitPlugin.mockReturnValue({
-      call: vi.fn(() => ({})),
-    } as unknown as ReturnType<
-      typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
-    >);
-  });
-
-  it("renders the camera for the system's current lens", () => {
-    const system = new UseSmileIDCameraSystem(CameraLens.back);
-    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-
-    expect(mockedUseCameraDevice).toHaveBeenCalledWith(CameraLens.back);
-    expect(cameraProps(root).photo).toBe(true);
-    expect(cameraProps(root).outputOrientation).toBe("device");
-  });
-
-  it("omits the camera entirely when no device is available", () => {
-    mockedUseCameraDevice.mockReturnValue(
-      undefined as unknown as CameraDevice as CameraDevice,
-    );
-    const system = new UseSmileIDCameraSystem();
-    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-
-    expect(findCameras(root)).toHaveLength(0);
-    // The tap surface still mounts so overlays render without a device.
-    expect(root.findAllByType(Pressable)).toHaveLength(1);
-  });
-
-  it("drives isActive off the system's streaming state", async () => {
-    const system = new UseSmileIDCameraSystem();
-    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-    expect(cameraProps(root).isActive).toBe(false);
-
-    await act(async () => {
-      await system.start();
-    });
-    expect(cameraProps(root).isActive).toBe(true);
-
-    act(() => {
-      system.stop();
-    });
-    expect(cameraProps(root).isActive).toBe(false);
-  });
-
-  it("pins the default fps and honours a configured override", () => {
-    const system = new UseSmileIDCameraSystem();
-    const first = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-    expect(cameraProps(first.root).fps).toBe(CameraDefaults.analysisTargetFps);
-
-    const configured = new UseSmileIDCameraSystem();
-    configured.configure({ fps: 24 });
-    const second = render(
-      <UseSmileIDCameraPreview cameraSystem={configured} />,
-    );
-    expect(cameraProps(second.root).fps).toBe(24);
-  });
-
-  it("requests a 4:3 30fps analysis format and forwards it when resolved", () => {
-    const format = { videoWidth: 640, videoHeight: 480 };
-    mockedUseCameraFormat.mockReturnValue(
-      format as unknown as ReturnType<typeof VisionCamera.useCameraFormat>,
-    );
-    const system = new UseSmileIDCameraSystem();
-    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-
-    expect(mockedUseCameraFormat).toHaveBeenCalledWith(fakeDevice, [
-      { videoAspectRatio: 4 / 3 },
-      {
-        videoResolution: {
-          width: CameraDefaults.analysisTargetResolution.width,
-          height: CameraDefaults.analysisTargetResolution.height,
-        },
-      },
-      { fps: CameraDefaults.analysisTargetFps },
-    ]);
-    expect(cameraProps(root).format).toBe(format);
-  });
-
-  it("omits the format key entirely when none resolves", () => {
-    const system = new UseSmileIDCameraSystem();
-    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-    expect("format" in cameraProps(root)).toBe(false);
-  });
-
-  it("attaches the camera ref on mount and detaches it on unmount", () => {
-    const system = new UseSmileIDCameraSystem();
-    const attachRef = vi.spyOn(system, "attachRef");
-    const tree = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-
-    expect(attachRef).toHaveBeenCalledTimes(1);
-    expect(attachRef.mock.calls[0]?.[0]).not.toBeNull();
-
-    act(() => {
-      tree.unmount();
-    });
-    expect(attachRef).toHaveBeenLastCalledWith(null);
-  });
-
-  it("unsubscribes from the system on unmount", () => {
-    const system = new UseSmileIDCameraSystem();
-    const unsubscribe = vi.fn();
-    vi.spyOn(system, "subscribe").mockReturnValue(unsubscribe);
-
-    const tree = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-    expect(unsubscribe).not.toHaveBeenCalled();
-
-    act(() => {
-      tree.unmount();
-    });
-    expect(unsubscribe).toHaveBeenCalledTimes(1);
-  });
-
-  it("passes live state and focus state to function-as-children overlays", async () => {
-    const system = new UseSmileIDCameraSystem();
-    const seen: Array<{ state: CameraSystemState; focusState: FocusState }> =
-      [];
-    render(
-      <UseSmileIDCameraPreview cameraSystem={system}>
-        {(args) => {
-          seen.push(args);
-          return null;
-        }}
-      </UseSmileIDCameraPreview>,
-    );
-
-    expect(seen[0]?.state.isStreaming).toBe(false);
-    expect(seen[0]?.focusState.kind).toBe("unspecified");
-
-    await act(async () => {
-      await system.start();
-    });
-    const latest = seen[seen.length - 1];
-    expect(latest?.state.isStreaming).toBe(true);
-  });
-
-  it("renders plain node children inside the tap surface", () => {
-    const system = new UseSmileIDCameraSystem();
-    const { root } = render(
-      <UseSmileIDCameraPreview cameraSystem={system}>
-        <View testID="si_overlay" />
-      </UseSmileIDCameraPreview>,
-    );
-    expect(
-      root.findAllByProps({ testID: "si_overlay" }).length,
-    ).toBeGreaterThan(0);
-  });
-
-  it("normalises a tap into [0..1] focus coordinates after layout", () => {
-    const system = new UseSmileIDCameraSystem();
-    const tapToFocus = vi
-      .spyOn(system, "tapToFocus")
-      .mockResolvedValue(undefined);
-    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-
-    layout(root, 200, 400);
-    tap(root, 50, 100);
-
-    expect(tapToFocus).toHaveBeenCalledWith({ x: 0.25, y: 0.25 });
-  });
-
-  it("ignores taps before the preview has been laid out", () => {
-    const system = new UseSmileIDCameraSystem();
-    const tapToFocus = vi
-      .spyOn(system, "tapToFocus")
-      .mockResolvedValue(undefined);
-    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-
-    tap(root, 50, 100);
-    expect(tapToFocus).not.toHaveBeenCalled();
-
-    // A zero-height layout is still degenerate — division would be Infinity.
-    layout(root, 200, 0);
-    tap(root, 50, 100);
-    expect(tapToFocus).not.toHaveBeenCalled();
-  });
-
-  it("skips plugin initialisation when no frame analysis is supplied", () => {
-    const system = new UseSmileIDCameraSystem();
-    const { root } = render(<UseSmileIDCameraPreview cameraSystem={system} />);
-
-    expect(mockedInitPlugin).not.toHaveBeenCalled();
-    expect("frameProcessor" in cameraProps(root)).toBe(false);
-  });
-
-  it("initialises the named plugin and attaches a frame processor", () => {
-    const system = new UseSmileIDCameraSystem();
-    const onResult = vi.fn();
-    const { root } = render(
-      <UseSmileIDCameraPreview
-        cameraSystem={system}
-        frameAnalysis={{ pluginName: "UseSmileIDFaceScan", onResult }}
-      />,
-    );
-
-    expect(mockedInitPlugin).toHaveBeenCalledWith("UseSmileIDFaceScan", {});
-    expect(cameraProps(root).frameProcessor).toBeTypeOf("function");
-  });
-
-  it("forwards each frame's raw result to onResult with the device rotation", () => {
-    const call = vi.fn(() => ({ state: { type: "initial" } }));
-    mockedInitPlugin.mockReturnValue({ call } as unknown as ReturnType<
-      typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
-    >);
-    const system = new UseSmileIDCameraSystem();
-    const onResult = vi.fn();
-    const { root } = render(
-      <UseSmileIDCameraPreview
-        cameraSystem={system}
-        frameAnalysis={{ pluginName: "UseSmileIDFaceScan", onResult }}
-      />,
-    );
-
-    act(() => {
-      cameraProps(root).onOutputOrientationChanged("landscape-left");
-    });
-
-    const frame = { width: 640, height: 480 };
-    const worklet = cameraProps(root).frameProcessor as (
-      frame: unknown,
-    ) => void;
-    worklet(frame);
-
-    expect(call).toHaveBeenCalledWith(frame, { rotation: 90 });
-    expect(onResult).toHaveBeenCalledWith({ state: { type: "initial" } });
-  });
-
-  it("frame processor is inert when the plugin failed to initialise", () => {
-    mockedInitPlugin.mockReturnValue(
-      null as unknown as ReturnType<
-        typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
-      >,
-    );
-    const system = new UseSmileIDCameraSystem();
-    const onResult = vi.fn();
-    render(
-      <UseSmileIDCameraPreview
-        cameraSystem={system}
-        frameAnalysis={{ pluginName: "UseSmileIDFaceScan", onResult }}
-      />,
-    );
-
-    const worklet = mockedUseFrameProcessor.mock.calls[0]?.[0] as (
-      frame: unknown,
-    ) => void;
-    expect(() => worklet({ width: 1, height: 1 })).not.toThrow();
-    expect(onResult).not.toHaveBeenCalled();
-  });
-
-  it("reports a missing native plugin exactly once through onError", () => {
-    mockedInitPlugin.mockReturnValue(
-      null as unknown as ReturnType<
-        typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
-      >,
-    );
-    const system = new UseSmileIDCameraSystem();
-    const onError = vi.fn();
-    const frameAnalysis = {
-      pluginName: "UseSmileIDMissingPlugin",
-      onResult: vi.fn(),
-      onError,
-    };
-    const tree = render(
-      <UseSmileIDCameraPreview
-        cameraSystem={system}
-        frameAnalysis={frameAnalysis}
-      />,
-    );
-
-    expect(onError).toHaveBeenCalledTimes(1);
-    expect(onError.mock.calls[0]?.[0]).toBeInstanceOf(
-      FrameProcessorPluginNotRegisteredException,
-    );
-
-    // A re-render with the same plugin name must not re-fire.
-    act(() => {
-      tree.update(
-        <UseSmileIDCameraPreview
-          cameraSystem={system}
-          frameAnalysis={frameAnalysis}
-        />,
-      );
-    });
-    expect(onError).toHaveBeenCalledTimes(1);
-  });
-
-  it("stays silent when the plugin resolves", () => {
-    const system = new UseSmileIDCameraSystem();
-    const onError = vi.fn();
-    render(
-      <UseSmileIDCameraPreview
-        cameraSystem={system}
-        frameAnalysis={{
-          pluginName: "UseSmileIDFaceScan",
-          onResult: vi.fn(),
-          onError,
-        }}
-      />,
-    );
-    expect(onError).not.toHaveBeenCalled();
-  });
-
-  it("picks up a swapped onError handler without re-firing the effect", () => {
-    mockedInitPlugin.mockReturnValue(
-      null as unknown as ReturnType<
-        typeof VisionCamera.VisionCameraProxy.initFrameProcessorPlugin
-      >,
-    );
-    const system = new UseSmileIDCameraSystem();
-    const first = vi.fn();
-    const second = vi.fn();
-    const onResult = vi.fn();
-    const tree = render(
-      <UseSmileIDCameraPreview
-        cameraSystem={system}
-        frameAnalysis={{
-          pluginName: "UseSmileIDMissingPlugin",
-          onResult,
-          onError: first,
-        }}
-      />,
-    );
-    expect(first).toHaveBeenCalledTimes(1);
-
-    act(() => {
-      tree.update(
-        <UseSmileIDCameraPreview
-          cameraSystem={system}
-          frameAnalysis={{
-            pluginName: "UseSmileIDMissingPlugin",
-            onResult,
-            onError: second,
-          }}
-        />,
-      );
-    });
-    expect(second).not.toHaveBeenCalled();
-    expect(first).toHaveBeenCalledTimes(1);
-  });
-});

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();
-  });
-});