@smileid/usesmileid 12.0.1 → 12.1.0

package/src/presentation/flow/validation/validation_state.ts

@@ -1,65 +0,0 @@
-import { IssueSeverity } from "../../../core/exception/issue_severity";
-import type { UseSmileIDValidationException } from "../../../core/exception/use_smile_id_validation_exception";
-
-export { IssueSeverity };
-
-/**
- * Validation state types.
- *
- * The shape is a discriminated union: narrow on `valid` to access
- * `issues`. Compile-time exhaustiveness via `switch (state.valid)`.
- */
-
-/**
- * One validation finding. Each issue is a typed exception subclass —
- * partners can `instanceof EmptyScreensBlockException` /
- * `instanceof InvalidScreenOrderException` etc. to narrow on the
- * specific rule, or pivot on `errorCode` for an exhaustive switch.
- *
- * Type alias rather than a separate plain-object record so the
- * validator output and the thrown exception are the same value —
- * partner tooling that forwards issues across platforms reads the
- * same fields everywhere.
- */
-export type ValidationIssue = UseSmileIDValidationException;
-
-/**
- * Result of running the flow validator.
- *
- * - `valid: true` — every rule passed (no errors and no warnings).
- * - `valid: false` — at least one error issue. `issues` is non-empty
- *   and may contain a mix of `error` and `warning` entries.
- */
-export type ValidationState = { readonly valid: true } | ValidationStateInvalid;
-
-/**
- * The invalid branch of [ValidationState] — carries one or more typed
- * validation issues. `FlowBuildResult.invalid` payloads,
- * `BuilderValidationException.validationState`, and the `b.validate()`
- * invalid result all use this exact shape.
- */
-export type ValidationStateInvalid = {
-  readonly valid: false;
-  readonly issues: readonly ValidationIssue[];
-};
-
-const VALID_STATE: ValidationState = Object.freeze({ valid: true });
-
-/**
- * Construct a `ValidationState`.
- *
- * `ValidationState.valid` returns the canonical "no issues" sentinel
- * (frozen) — partners can compare via `state.valid === true` without
- * worrying about reference identity.
- *
- * `ValidationState.invalid(issues)` returns a frozen invalid state.
- * If `issues` is empty, returns the valid sentinel — `validate()`
- * implementations don't need to special-case the empty path.
- */
-export const ValidationState = {
-  valid: VALID_STATE,
-  invalid(issues: readonly ValidationIssue[]): ValidationState {
-    if (issues.length === 0) return VALID_STATE;
-    return Object.freeze({ valid: false, issues: Object.freeze([...issues]) });
-  },
-} as const;

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

@@ -1,112 +0,0 @@
-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

@@ -1,398 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { UseSmileIDScanState } from "@smileid/usesmileid_bridge";
-import { UseSmileIDScanStateType } 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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.Found },
-      false,
-    );
-    expect(found.feedbackKey).toBe("si_capturing");
-    const satisfied = mapSelfieUiState(
-      { type: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.Found },
-      { type: UseSmileIDScanStateType.Satisfied },
-    ] satisfies UseSmileIDScanState[]) {
-      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: UseSmileIDScanStateType.Finished }, true)
-        .feedbackKey,
-    ).toBe("si_selfie_capture_complete");
-  });
-
-  it("zeroes captureProgress everywhere — the oval never fills under ESS", () => {
-    for (const scanState of [
-      { type: UseSmileIDScanStateType.Found, captureProgress: 0.6 },
-      { type: UseSmileIDScanStateType.Satisfied },
-      { type: UseSmileIDScanStateType.Finished },
-      { type: UseSmileIDScanStateType.HeadTurn, currentDirection: "left" },
-    ] satisfies UseSmileIDScanState[]) {
-      expect(mapSelfieUiState(scanState, true).captureProgress).toBe(0);
-    }
-  });
-
-  it("keeps explicit guidance keys ahead of hold-still during found", () => {
-    const ui = mapSelfieUiState(
-      { type: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.HeadTurn,
-        currentDirection: "left",
-        poseMatched: true,
-      },
-      true,
-    );
-    expect(matched.animationDirection).toBe("left");
-    expect(matched.poseMatched).toBe(true);
-
-    const pending = mapSelfieUiState(
-      { type: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.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: UseSmileIDScanStateType.Initial },
-        CaptureType.selfie,
-        true,
-      ).feedbackKey,
-    ).toBe("si_ess_capture_initial_instruction");
-    expect(
-      mapCaptureUiState(
-        { type: UseSmileIDScanStateType.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: UseSmileIDScanStateType.Unsatisfied },
-        { type: UseSmileIDScanStateType.Found },
-      ),
-    ).toBe(true);
-  });
-
-  it("returns true for unsatisfied → initial", () => {
-    expect(
-      isSessionBoundary(
-        { type: UseSmileIDScanStateType.Unsatisfied },
-        { type: UseSmileIDScanStateType.Initial },
-      ),
-    ).toBe(true);
-  });
-
-  it("returns true for timeout → initial (session restart)", () => {
-    expect(
-      isSessionBoundary(
-        { type: UseSmileIDScanStateType.Timeout },
-        { type: UseSmileIDScanStateType.Initial },
-      ),
-    ).toBe(true);
-  });
-
-  it("returns true for finished → initial (session restart)", () => {
-    expect(
-      isSessionBoundary(
-        { type: UseSmileIDScanStateType.Finished },
-        { type: UseSmileIDScanStateType.Initial },
-      ),
-    ).toBe(true);
-  });
-
-  it("returns false for found → unsatisfied (entering unsatisfied, not leaving)", () => {
-    expect(
-      isSessionBoundary(
-        { type: UseSmileIDScanStateType.Found },
-        { type: UseSmileIDScanStateType.Unsatisfied },
-      ),
-    ).toBe(false);
-  });
-
-  it("returns false for same-type transition (found → found)", () => {
-    expect(
-      isSessionBoundary(
-        { type: UseSmileIDScanStateType.Found },
-        { type: UseSmileIDScanStateType.Found },
-      ),
-    ).toBe(false);
-  });
-
-  it("returns false for initial → found (normal forward progression)", () => {
-    expect(
-      isSessionBoundary(
-        { type: UseSmileIDScanStateType.Initial },
-        { type: UseSmileIDScanStateType.Found },
-      ),
-    ).toBe(false);
-  });
-
-  it("returns false for timeout → found (only initial restarts after a terminal state)", () => {
-    expect(
-      isSessionBoundary(
-        { type: UseSmileIDScanStateType.Timeout },
-        { type: UseSmileIDScanStateType.Found },
-      ),
-    ).toBe(false);
-  });
-});

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

@@ -1,63 +0,0 @@
-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");
-  });
-});