@smileid/usesmileid 12.0.0-beta01

package/src/presentation/screen/__tests__/capture_screen_helpers.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import {
+  isStartCaptureEnabled,
+  resolveCaptureFeedback,
+} from "../helpers/capture_screen_helpers";
+import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
+import { UseSmileIDLocalizations } from "../../../l10n/use_smile_id_localizations";
+
+const loc = new UseSmileIDLocalizations({});
+
+describe("resolveCaptureFeedback", () => {
+  it("falls back to the canonical initial instruction for non-feedback states", () => {
+    // Concrete scenario: app just mounted; overlay still in
+    // INSTRUCTION. The feedback bubble must surface the
+    // canonical "centre your face …" copy so users know what to
+    // do before the analyzer has anything to say.
+    expect(
+      resolveCaptureFeedback(UseSmileIDOverlayState.INSTRUCTION, loc),
+    ).toBe(loc.siCaptureInitialInstruction);
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.IDLE, loc)).toBe(
+      loc.siCaptureInitialInstruction,
+    );
+  });
+
+  it("routes each face-feedback state to its localised copy", () => {
+    // Concrete scenario: an analyzer firing rapid feedback
+    // changes (TOO_CLOSE → CENTER_FACE → READY). Each render
+    // must surface the matching string — wrong mapping would
+    // confuse users mid-capture.
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.TOO_CLOSE, loc)).toBe(
+      loc.siCaptureTooClose,
+    );
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.TOO_FAR, loc)).toBe(
+      loc.siCaptureTooFar,
+    );
+    expect(
+      resolveCaptureFeedback(UseSmileIDOverlayState.FACE_NOT_CENTERED, loc),
+    ).toBe(loc.siCaptureCenterFace);
+    expect(
+      resolveCaptureFeedback(UseSmileIDOverlayState.MULTIPLE_FACES, loc),
+    ).toBe(loc.siCaptureMultipleFaces);
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.LOW_LIGHT, loc)).toBe(
+      loc.siCaptureLowLight,
+    );
+    expect(
+      resolveCaptureFeedback(UseSmileIDOverlayState.BRIGHT_LIGHT, loc),
+    ).toBe(loc.siCaptureBrightLight);
+    expect(
+      resolveCaptureFeedback(UseSmileIDOverlayState.WRONG_ORIENTATION, loc),
+    ).toBe(loc.siCaptureRotateDevice);
+    expect(
+      resolveCaptureFeedback(UseSmileIDOverlayState.NOT_SMILING, loc),
+    ).toBe(loc.siCaptureSmile);
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.HEAD_TURN, loc)).toBe(
+      loc.siCaptureHoldSteady,
+    );
+  });
+
+  it("routes each directional MOVE_* state to its device-motion copy", () => {
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.MOVE_LEFT, loc)).toBe(
+      loc.siCaptureMoveLeft,
+    );
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.MOVE_RIGHT, loc)).toBe(
+      loc.siCaptureMoveRight,
+    );
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.MOVE_UP, loc)).toBe(
+      loc.siCaptureMoveHigher,
+    );
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.MOVE_DOWN, loc)).toBe(
+      loc.siCaptureMoveLower,
+    );
+  });
+
+  it("emits the ready state for FACE_DETECTED and READY", () => {
+    expect(
+      resolveCaptureFeedback(UseSmileIDOverlayState.FACE_DETECTED, loc),
+    ).toBe(loc.siCaptureReady);
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.READY, loc)).toBe(
+      loc.siCaptureReady,
+    );
+  });
+
+  it('switches to "Capturing…" while frames are being grabbed', () => {
+    expect(resolveCaptureFeedback(UseSmileIDOverlayState.CAPTURING, loc)).toBe(
+      loc.siCapturing,
+    );
+  });
+});
+
+describe("isStartCaptureEnabled", () => {
+  it("enables the start affordance exactly during INSTRUCTION", () => {
+    // The Start Capture button begins the analyzer pipeline; it
+    // doesn't snap a picture. So it's actionable only during the
+    // pre-flight INSTRUCTION state. Once the analyzer is running,
+    // the button is hidden and any in-flight tap from a partner
+    // slot that cached the press handler must be rejected by the
+    // closure-side gate.
+    expect(isStartCaptureEnabled(UseSmileIDOverlayState.INSTRUCTION)).toBe(
+      true,
+    );
+    expect(isStartCaptureEnabled(UseSmileIDOverlayState.TOO_CLOSE)).toBe(false);
+    expect(isStartCaptureEnabled(UseSmileIDOverlayState.LOW_LIGHT)).toBe(false);
+    expect(isStartCaptureEnabled(UseSmileIDOverlayState.READY)).toBe(false);
+    expect(isStartCaptureEnabled(UseSmileIDOverlayState.FACE_DETECTED)).toBe(
+      false,
+    );
+    expect(isStartCaptureEnabled(UseSmileIDOverlayState.CAPTURING)).toBe(false);
+    expect(isStartCaptureEnabled(UseSmileIDOverlayState.DOCUMENT_READY)).toBe(
+      false,
+    );
+  });
+});

package/src/presentation/screen/__tests__/capture_ui_state.test.ts

@@ -0,0 +1,379 @@
+import { describe, expect, it } from "vitest";
+import type { ScanState } from "@smileid/usesmileid_bridge";
+import { ScanStateType } from "@smileid/usesmileid_bridge";
+import { CaptureType } from "../../../core/models/ml_config";
+import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
+import {
+  isSessionBoundary,
+  mapCaptureUiState,
+  mapDocumentUiState,
+  mapSelfieUiState,
+  preCaptureUiState,
+  scannedDocumentUiState,
+  scannedUiState,
+  withEnhancedLivenessPolicy,
+} from "../helpers/capture_ui_state";
+
+describe("mapSelfieUiState — standard flow", () => {
+  it("maps initial to the standard primer", () => {
+    const ui = mapSelfieUiState({ type: ScanStateType.Initial }, false);
+    expect(ui.overlayState).toBe(UseSmileIDOverlayState.INSTRUCTION);
+    expect(ui.feedbackKey).toBe("si_capture_initial_instruction");
+    expect(ui.captureProgress).toBe(0);
+    expect(ui.animationDirection).toBeNull();
+  });
+
+  it("passes the analyzer feedback key through on found", () => {
+    const ui = mapSelfieUiState(
+      {
+        type: ScanStateType.Found,
+        feedback: "si_capture_move_left",
+        captureProgress: 0.4,
+      },
+      false,
+    );
+    expect(ui.overlayState).toBe(UseSmileIDOverlayState.MOVE_LEFT);
+    expect(ui.feedbackKey).toBe("si_capture_move_left");
+    expect(ui.captureProgress).toBe(0.4);
+  });
+
+  it("shows the in-capture copy on found-default and satisfied", () => {
+    // All checks passing means frames are being collected — the
+    // guidance reads "Capturing…", never the pre-start instruction.
+    const found = mapSelfieUiState({ type: ScanStateType.Found }, false);
+    expect(found.feedbackKey).toBe("si_capturing");
+    const satisfied = mapSelfieUiState(
+      { type: ScanStateType.Satisfied },
+      false,
+    );
+    expect(satisfied.feedbackKey).toBe("si_capturing");
+    expect(satisfied.overlayState).toBe(UseSmileIDOverlayState.CAPTURING);
+    // Forced to 1 so the ring completes even when the last interim
+    // frame undershot.
+    expect(satisfied.captureProgress).toBe(1);
+  });
+
+  it("maps finished through the shared terminal snapshot", () => {
+    const ui = mapSelfieUiState({ type: ScanStateType.Finished }, false);
+    expect(ui).toEqual(scannedUiState(false));
+    expect(ui.feedbackKey).toBe("si_selfie_capture_complete");
+    expect(ui.captureProgress).toBe(1);
+  });
+
+  it("maps timeout to idle with the timeout copy", () => {
+    const ui = mapSelfieUiState({ type: ScanStateType.Timeout }, false);
+    expect(ui.overlayState).toBe(UseSmileIDOverlayState.IDLE);
+    expect(ui.feedbackKey).toBe("si_capture_timeout");
+  });
+});
+
+describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
+  it("swaps the initial primer for the head-turn instruction", () => {
+    const ui = mapSelfieUiState({ type: ScanStateType.Initial }, true);
+    expect(ui.feedbackKey).toBe("si_ess_capture_initial_instruction");
+  });
+
+  it("shows hold-still through active capture (found-default / satisfied)", () => {
+    for (const scanState of [
+      { type: ScanStateType.Found },
+      { type: ScanStateType.Satisfied },
+    ] satisfies ScanState[]) {
+      expect(mapSelfieUiState(scanState, true).feedbackKey).toBe(
+        "si_ess_hold_still",
+      );
+    }
+    // Finished shows the completion copy in both modes; only the oval
+    // fill differs under Enhanced Smart Selfie.
+    expect(
+      mapSelfieUiState({ type: ScanStateType.Finished }, true).feedbackKey,
+    ).toBe("si_selfie_capture_complete");
+  });
+
+  it("zeroes captureProgress everywhere — the oval never fills under ESS", () => {
+    for (const scanState of [
+      { type: ScanStateType.Found, captureProgress: 0.6 },
+      { type: ScanStateType.Satisfied },
+      { type: ScanStateType.Finished },
+      { type: ScanStateType.HeadTurn, currentDirection: "left" },
+    ] satisfies ScanState[]) {
+      expect(mapSelfieUiState(scanState, true).captureProgress).toBe(0);
+    }
+  });
+
+  it("keeps explicit guidance keys ahead of hold-still during found", () => {
+    const ui = mapSelfieUiState(
+      { type: ScanStateType.Found, feedback: "si_capture_too_close" },
+      true,
+    );
+    expect(ui.feedbackKey).toBe("si_capture_too_close");
+  });
+
+  it("carries the head-turn direction and its look copy", () => {
+    const directions = [
+      ["left", "si_ess_look_left"],
+      ["right", "si_ess_look_right"],
+      ["up", "si_ess_look_up"],
+    ] as const;
+    for (const [direction, expectedKey] of directions) {
+      const ui = mapSelfieUiState(
+        { type: ScanStateType.HeadTurn, currentDirection: direction },
+        true,
+      );
+      expect(ui.overlayState).toBe(UseSmileIDOverlayState.HEAD_TURN);
+      expect(ui.animationDirection).toBe(direction);
+      expect(ui.feedbackKey).toBe(expectedKey);
+      expect(ui.captureProgress).toBe(0);
+    }
+  });
+
+  it("falls back to hold-steady when headTurn arrives without a direction", () => {
+    const ui = mapSelfieUiState({ type: ScanStateType.HeadTurn }, true);
+    expect(ui.feedbackKey).toBe("si_capture_hold_steady");
+    expect(ui.animationDirection).toBeNull();
+  });
+
+  it("threads poseMatched into the head-turn state (drives grey→green)", () => {
+    const matched = mapSelfieUiState(
+      {
+        type: ScanStateType.HeadTurn,
+        currentDirection: "left",
+        poseMatched: true,
+      },
+      true,
+    );
+    expect(matched.animationDirection).toBe("left");
+    expect(matched.poseMatched).toBe(true);
+
+    const pending = mapSelfieUiState(
+      { type: ScanStateType.HeadTurn, currentDirection: "left" },
+      true,
+    );
+    expect(pending.poseMatched).toBe(false);
+  });
+
+  it("surfaces mid-turn lighting / orientation coaching in the copy and hides the arrow", () => {
+    for (const feedback of [
+      "si_capture_low_light",
+      "si_capture_bright_light",
+      "si_capture_rotate_device",
+    ] as const) {
+      const ui = mapSelfieUiState(
+        {
+          type: ScanStateType.HeadTurn,
+          currentDirection: "left",
+          feedback,
+          poseMatched: true,
+        },
+        true,
+      );
+      expect(ui.feedbackKey).toBe(feedback);
+      // Blocking coaching hides the arrow and pauses pose-match.
+      expect(ui.animationDirection).toBeNull();
+      expect(ui.poseMatched).toBe(false);
+      expect(ui.captureProgress).toBe(0);
+    }
+  });
+
+  it("surfaces mid-turn position coaching (too_far / too_close / center) and hides the arrow", () => {
+    for (const feedback of [
+      "si_capture_too_far",
+      "si_capture_too_close",
+      "si_capture_center_face",
+    ] as const) {
+      const ui = mapSelfieUiState(
+        {
+          type: ScanStateType.HeadTurn,
+          currentDirection: "up",
+          feedback,
+          poseMatched: true,
+        },
+        true,
+      );
+      expect(ui.feedbackKey).toBe(feedback);
+      expect(ui.animationDirection).toBeNull();
+      expect(ui.poseMatched).toBe(false);
+    }
+  });
+
+  it("keeps the turn prompt and arrow for non-blocking feedback mid-turn (smile / blur / move)", () => {
+    // Non-blocking feedback must not hijack the prompt or hide the arrow.
+    for (const feedback of [
+      "si_capture_smile",
+      "si_capture_move_left",
+    ] as const) {
+      const ui = mapSelfieUiState(
+        {
+          type: ScanStateType.HeadTurn,
+          currentDirection: "right",
+          feedback,
+          poseMatched: true,
+        },
+        true,
+      );
+      expect(ui.feedbackKey).toBe("si_ess_look_right");
+      expect(ui.animationDirection).toBe("right");
+      // Non-blocking feedback leaves pose-match untouched.
+      expect(ui.poseMatched).toBe(true);
+    }
+  });
+});
+
+describe("withEnhancedLivenessPolicy", () => {
+  const filled = {
+    overlayState: UseSmileIDOverlayState.CAPTURING,
+    feedbackKey: "si_capturing",
+    captureProgress: 1,
+    animationDirection: null,
+    poseMatched: false,
+  } as const;
+
+  it("zeroes progress under ESS and is idempotent", () => {
+    const once = withEnhancedLivenessPolicy(filled, true);
+    expect(once.captureProgress).toBe(0);
+    const twice = withEnhancedLivenessPolicy(once, true);
+    expect(twice).toBe(once);
+  });
+
+  it("is the identity on the standard path", () => {
+    expect(withEnhancedLivenessPolicy(filled, false)).toBe(filled);
+  });
+});
+
+describe("document mapping", () => {
+  it("maps finished through the shared document terminal snapshot", () => {
+    const ui = mapDocumentUiState({ type: ScanStateType.Finished });
+    expect(ui).toEqual(scannedDocumentUiState());
+    expect(ui.feedbackKey).toBe("si_document_capture_complete");
+    expect(ui.captureProgress).toBe(1);
+  });
+
+  it("passes document feedback keys through on found", () => {
+    const ui = mapDocumentUiState({
+      type: ScanStateType.Found,
+      feedback: "si_document_too_far",
+    });
+    expect(ui.overlayState).toBe(UseSmileIDOverlayState.DOCUMENT_TOO_FAR);
+    expect(ui.feedbackKey).toBe("si_document_too_far");
+  });
+
+  it("treats a degenerate headTurn as the pre-capture instruction", () => {
+    const ui = mapDocumentUiState({ type: ScanStateType.HeadTurn });
+    expect(ui.overlayState).toBe(UseSmileIDOverlayState.INSTRUCTION);
+    expect(ui.feedbackKey).toBe("si_document_initial_instruction");
+  });
+});
+
+describe("preCaptureUiState", () => {
+  it("stays IDLE (no green flash) and primes the flow's initial instruction", () => {
+    const standard = preCaptureUiState(CaptureType.selfie, false);
+    expect(standard.overlayState).toBe(UseSmileIDOverlayState.IDLE);
+    // Pre-capture shows the press-Start instruction, matching the
+    // visible Start Capture button.
+    expect(standard.feedbackKey).toBe("si_start_capture_instruction");
+    expect(standard.captureProgress).toBe(0);
+
+    // ESS pre-capture also shows the press-Start copy; the ESS primer
+    // belongs to the scanning Initial state.
+    expect(preCaptureUiState(CaptureType.selfie, true).feedbackKey).toBe(
+      "si_start_capture_instruction",
+    );
+    expect(preCaptureUiState(CaptureType.document, false).feedbackKey).toBe(
+      "si_document_initial_instruction",
+    );
+  });
+});
+
+describe("mapCaptureUiState dispatch", () => {
+  it("routes by capture type", () => {
+    expect(
+      mapCaptureUiState(
+        { type: ScanStateType.Initial },
+        CaptureType.selfie,
+        true,
+      ).feedbackKey,
+    ).toBe("si_ess_capture_initial_instruction");
+    expect(
+      mapCaptureUiState(
+        { type: ScanStateType.Initial },
+        CaptureType.document,
+        // ESS is a selfie-only concept; the flag must not leak into
+        // the document mapping.
+        true,
+      ).feedbackKey,
+    ).toBe("si_document_initial_instruction");
+  });
+});
+
+describe("isSessionBoundary", () => {
+  it("returns true for unsatisfied → found (leaving unsatisfied is a boundary)", () => {
+    expect(
+      isSessionBoundary(
+        { type: ScanStateType.Unsatisfied },
+        { type: ScanStateType.Found },
+      ),
+    ).toBe(true);
+  });
+
+  it("returns true for unsatisfied → initial", () => {
+    expect(
+      isSessionBoundary(
+        { type: ScanStateType.Unsatisfied },
+        { type: ScanStateType.Initial },
+      ),
+    ).toBe(true);
+  });
+
+  it("returns true for timeout → initial (session restart)", () => {
+    expect(
+      isSessionBoundary(
+        { type: ScanStateType.Timeout },
+        { type: ScanStateType.Initial },
+      ),
+    ).toBe(true);
+  });
+
+  it("returns true for finished → initial (session restart)", () => {
+    expect(
+      isSessionBoundary(
+        { type: ScanStateType.Finished },
+        { type: ScanStateType.Initial },
+      ),
+    ).toBe(true);
+  });
+
+  it("returns false for found → unsatisfied (entering unsatisfied, not leaving)", () => {
+    expect(
+      isSessionBoundary(
+        { type: ScanStateType.Found },
+        { type: ScanStateType.Unsatisfied },
+      ),
+    ).toBe(false);
+  });
+
+  it("returns false for same-type transition (found → found)", () => {
+    expect(
+      isSessionBoundary(
+        { type: ScanStateType.Found },
+        { type: ScanStateType.Found },
+      ),
+    ).toBe(false);
+  });
+
+  it("returns false for initial → found (normal forward progression)", () => {
+    expect(
+      isSessionBoundary(
+        { type: ScanStateType.Initial },
+        { type: ScanStateType.Found },
+      ),
+    ).toBe(false);
+  });
+
+  it("returns false for timeout → found (only initial restarts after a terminal state)", () => {
+    expect(
+      isSessionBoundary(
+        { type: ScanStateType.Timeout },
+        { type: ScanStateType.Found },
+      ),
+    ).toBe(false);
+  });
+});

package/src/presentation/screen/__tests__/consent_screen_helpers.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildConsentRows,
+  composeConsentSubtitle,
+} from "../helpers/consent_screen_helpers";
+import { UseSmileIDLocalizations } from "../../../l10n/use_smile_id_localizations";
+
+const loc = new UseSmileIDLocalizations({});
+
+describe("buildConsentRows", () => {
+  it("returns the four canonical rows in the locked order", () => {
+    // Concrete scenario: a future refactor reorders these rows.
+    // Pin the order.
+    const rows = buildConsentRows(loc);
+    expect(rows.map((r) => r.key)).toEqual([
+      "contact",
+      "personal",
+      "biometric",
+      "device",
+    ]);
+  });
+
+  it("reads each label from the localization accessor", () => {
+    const rows = buildConsentRows(loc);
+    expect(rows[0]?.label).toBe(loc.siConsentContact);
+    expect(rows[1]?.label).toBe(loc.siConsentPersonal);
+    expect(rows[2]?.label).toBe(loc.siConsentBiometric);
+    expect(rows[3]?.label).toBe(loc.siConsentDevice);
+  });
+});
+
+describe("composeConsentSubtitle", () => {
+  it("substitutes {allow}, {smile_id}, and {partner} tokens with the correct values", () => {
+    // Concrete scenario: partner is "Acme Corp". The composed
+    // subtitle must read naturally with all three tokens replaced;
+    // any leftover `{name}` literal is a translation/QA bug.
+    const subtitle = composeConsentSubtitle("Acme Corp", loc);
+    expect(subtitle).toContain("Allow");
+    expect(subtitle).toContain("Smile ID");
+    expect(subtitle).toContain("Acme Corp");
+    expect(subtitle).not.toContain("{allow}");
+    expect(subtitle).not.toContain("{smile_id}");
+    expect(subtitle).not.toContain("{partner}");
+  });
+
+  it("preserves the rest of the localized template verbatim", () => {
+    // Concrete scenario: a sloppy regex-based substitution might
+    // collapse whitespace or drop punctuation. We use literal
+    // string-split-and-join, so the surrounding template is byte-
+    // identical except for the substituted tokens.
+    const subtitle = composeConsentSubtitle("Foo", loc);
+    expect(subtitle).toContain("consent to Smile ID collecting");
+    expect(subtitle).toContain("sharing the results with Foo");
+  });
+
+  it("handles partner names with special characters safely", () => {
+    // Concrete scenario: partner name contains regex metachars like
+    // `$` or `.` — the `.split().join()` pattern is regex-free, so
+    // it must not interpret them as patterns.
+    const subtitle = composeConsentSubtitle("A.$Co", loc);
+    expect(subtitle).toContain("A.$Co");
+  });
+});

package/src/presentation/screen/__tests__/ess_turn_haptics.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import * as Haptics from "expo-haptics";
+import type { ScanState } from "@smileid/usesmileid_bridge";
+import { ScanStateType } from "@smileid/usesmileid_bridge";
+import {
+  essTurnHaptic,
+  triggerEssTurnHaptic,
+} from "../helpers/ess_turn_haptics";
+
+const headTurn = (direction?: "left" | "right" | "up"): ScanState =>
+  direction === undefined
+    ? { type: ScanStateType.HeadTurn }
+    : { type: ScanStateType.HeadTurn, currentDirection: direction };
+
+describe("essTurnHaptic", () => {
+  it("fires intermediate when the requested direction advances", () => {
+    expect(essTurnHaptic(headTurn("left"), headTurn("right"))).toBe(
+      "intermediate",
+    );
+    expect(essTurnHaptic(headTurn("right"), headTurn("up"))).toBe(
+      "intermediate",
+    );
+  });
+
+  it("fires final when leaving the head-turn phase toward capture", () => {
+    for (const next of [
+      ScanStateType.Found,
+      ScanStateType.Satisfied,
+      ScanStateType.Finished,
+    ] as const) {
+      expect(essTurnHaptic(headTurn("up"), { type: next })).toBe("final");
+    }
+  });
+
+  it("never fires on a reset (head turn abandoned to initial / timeout)", () => {
+    expect(
+      essTurnHaptic(headTurn("left"), { type: ScanStateType.Initial }),
+    ).toBeNull();
+    expect(
+      essTurnHaptic(headTurn("left"), { type: ScanStateType.Timeout }),
+    ).toBeNull();
+  });
+
+  it("does not fire when the same direction repeats (no completion yet)", () => {
+    expect(essTurnHaptic(headTurn("left"), headTurn("left"))).toBeNull();
+  });
+
+  it("does not fire when the previous state was not a directed head turn", () => {
+    // Entering a head turn is not completing one.
+    expect(
+      essTurnHaptic({ type: ScanStateType.Found }, headTurn("left")),
+    ).toBeNull();
+    // A head turn with no direction yet has nothing to complete.
+    expect(essTurnHaptic(headTurn(), headTurn("left"))).toBeNull();
+  });
+});
+
+describe("triggerEssTurnHaptic", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("plays a light impact between turns", () => {
+    triggerEssTurnHaptic("intermediate");
+    expect(Haptics.impactAsync).toHaveBeenCalledWith(
+      Haptics.ImpactFeedbackStyle.Light,
+    );
+    expect(Haptics.notificationAsync).not.toHaveBeenCalled();
+  });
+
+  it("plays a success notification on the final turn", () => {
+    triggerEssTurnHaptic("final");
+    expect(Haptics.notificationAsync).toHaveBeenCalledWith(
+      Haptics.NotificationFeedbackType.Success,
+    );
+    expect(Haptics.impactAsync).not.toHaveBeenCalled();
+  });
+});