@smileid/usesmileid 12.0.2 → 12.1.0

package/src/camera/use_smile_id_frame_stream.ts

@@ -1,189 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef } from "react";
-import type {
-  DocumentAnalyzer,
-  FaceAnalyzer,
-} from "@smileid/usesmileid_platform_interface";
-import type {
-  DocumentScanResult,
-  FaceScanResult,
-} from "@smileid/usesmileid_bridge";
-import {
-  documentScanResultSchema,
-  faceScanResultSchema,
-  FrameProcessingException,
-} from "@smileid/usesmileid_bridge";
-
-/**
- * Options accepted by `useSmileIDFrameStream`. `onError` is typed
- * `unknown` — failures arrive both as Zod schema rejections and as
- * `FrameProcessingException`s; narrow with `instanceof` in the
- * callback if you need typed routing.
- */
-export type UseSmileIDFrameStreamOptions = {
-  /**
-   * Called when a frame's plugin result fails to validate or carries a
-   * native error marker. The stream keeps running — the next frame is
-   * processed normally.
-   */
-  readonly onError?: (error: unknown) => void;
-};
-
-/**
- * Return value of `useSmileIDFrameStream`. Wire `onFrameResult` into
- * the capture surface's per-frame result callback — it receives the
- * raw map the native frame processor plugin returned to the worklet.
- */
-export type UseSmileIDFrameStream = {
-  readonly onFrameResult: (rawResult: unknown) => void;
-};
-
-/**
- * Per-frame scan-result streaming hook. Pixels never reach JS — the
- * provider's native frame processor plugin hands the worklet a small
- * result map; this hook receives the raw map on the JS thread,
- * validates it against the wire schema (Zod), and routes the typed
- * result to `onResult`.
- *
- * ```tsx
- * const { onFrameResult } = useSmileIDFrameStream(faceAnalyzer, setFaceState);
- *
- * <UseSmileIDCameraPreview
- *   cameraSystem={cameraSystem}
- *   frameAnalysis={{
- *     pluginName: faceAnalyzer.frameProcessorPluginName,
- *     onResult: onFrameResult,
- *   }}
- * />;
- * ```
- *
- * Backpressure lives natively: the plugin blocks the frame-processor
- * thread per scan, so mid-scan frames are dropped before reaching JS;
- * the JS-side busy gate only guards re-entrant dispatch.
- *
- * The hook does not own the analyzer — configure / close it yourself.
- * Results arriving after unmount are dropped.
- */
-export function useSmileIDFrameStream(
-  analyzer: FaceAnalyzer | null,
-  onResult: (result: FaceScanResult) => void,
-  options?: UseSmileIDFrameStreamOptions,
-): UseSmileIDFrameStream;
-export function useSmileIDFrameStream(
-  analyzer: DocumentAnalyzer | null,
-  onResult: (result: DocumentScanResult) => void,
-  options?: UseSmileIDFrameStreamOptions,
-): UseSmileIDFrameStream;
-export function useSmileIDFrameStream(
-  analyzer: FaceAnalyzer | DocumentAnalyzer | null,
-  onResult:
-    | ((result: FaceScanResult) => void)
-    | ((result: DocumentScanResult) => void),
-  options?: UseSmileIDFrameStreamOptions,
-): UseSmileIDFrameStream {
-  const analyzerRef = useRef(analyzer);
-  const onResultRef = useRef(onResult);
-  const onErrorRef = useRef(options?.onError);
-  const busyRef = useRef(false);
-  const mountedRef = useRef(true);
-
-  useEffect(() => {
-    analyzerRef.current = analyzer;
-  }, [analyzer]);
-
-  useEffect(() => {
-    onResultRef.current = onResult;
-  }, [onResult]);
-
-  useEffect(() => {
-    onErrorRef.current = options?.onError;
-  }, [options?.onError]);
-
-  useEffect(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-
-  const onFrameResult = useCallback((rawResult: unknown): void => {
-    const onError = onErrorRef.current;
-    dispatchFrameResult({
-      raw: rawResult,
-      analyzer: analyzerRef.current,
-      isBusy: () => busyRef.current,
-      setBusy: (value) => {
-        busyRef.current = value;
-      },
-      isMounted: () => mountedRef.current,
-      // Boundary cast: the overload pairing guarantees the analyzer
-      // shape matches the callback shape (face↔face / document↔document);
-      // the implementation signature widens both.
-      onResult: onResultRef.current as (
-        result: FaceScanResult | DocumentScanResult,
-      ) => void,
-      ...(onError !== undefined ? { onError } : {}),
-    });
-  }, []);
-
-  // Stable handle — an identity change here rebuilds the camera's
-  // frame processor, so memoise.
-  return useMemo(() => ({ onFrameResult }), [onFrameResult]);
-}
-
-/**
- * Extract the error marker, if present — native plugins signal
- * frame-level failures by returning `{ error: "<reason>" }` instead of
- * a scan-result map.
- */
-function readPluginError(raw: unknown): string | null {
-  if (raw === null || typeof raw !== "object") return null;
-  // Boundary cast: `raw` crossed the worklet bridge as `unknown`; the
-  // key's type is verified before use.
-  const reason = (raw as Record<string, unknown>)["error"];
-  return typeof reason === "string" ? reason : null;
-}
-
-/**
- * Pure dispatch logic extracted from the hook so vitest can exercise
- * the busy-gate, mounted-gate, error-marker, and schema-validation
- * branches without standing up a React renderer.
- *
- * @internal
- */
-export function dispatchFrameResult(args: {
-  /** Raw value the native frame processor plugin returned to the worklet. */
-  readonly raw: unknown;
-  readonly analyzer:
-    | Pick<FaceAnalyzer, "kind">
-    | Pick<DocumentAnalyzer, "kind">
-    | null;
-  readonly isBusy: () => boolean;
-  readonly setBusy: (value: boolean) => void;
-  readonly isMounted: () => boolean;
-  readonly onResult: (result: FaceScanResult | DocumentScanResult) => void;
-  readonly onError?: (error: unknown) => void;
-}): void {
-  const { raw, analyzer, isBusy, setBusy, isMounted, onResult, onError } = args;
-
-  if (!analyzer) return;
-  if (isBusy()) return;
-
-  setBusy(true);
-  try {
-    const errorReason = readPluginError(raw);
-    if (errorReason !== null) {
-      throw new FrameProcessingException({ reason: errorReason });
-    }
-    const result =
-      analyzer.kind === "face"
-        ? faceScanResultSchema.parse(raw)
-        : documentScanResultSchema.parse(raw);
-    if (!isMounted()) return;
-    onResult(result);
-  } catch (error) {
-    if (!isMounted()) return;
-    onError?.(error);
-  } finally {
-    setBusy(false);
-  }
-}

package/src/core/exception/__tests__/builder_validation_exceptions.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { DuplicateScreenTypeException } from "../duplicate_screen_type_exception";
-import { InvalidMissingCaptureTypeException } from "../invalid_missing_capture_type_exception";
-import { InvalidSelfieCaptureConfigException } from "../invalid_selfie_capture_config_exception";
-import { LivenessFrameCountException } from "../liveness_frame_count_exception";
-import { UseSmileIDErrorCode } from "../use_smile_id_error_code";
-
-/** Typed builder/validation exceptions: pin `errorCode`, message, and `errorDetails`. */
-describe("DuplicateScreenTypeException", () => {
-  it("names the duplicated type + indices and freezes the details", () => {
-    const exception = new DuplicateScreenTypeException({
-      screenType: "consent",
-      indices: [0, 3],
-    });
-
-    expect(exception).toBeInstanceOf(Error);
-    expect(exception.errorCode).toBe(
-      UseSmileIDErrorCode.Builder.DuplicateScreenType,
-    );
-    expect(exception.message).toContain("consent");
-    expect(exception.message).toContain("0, 3");
-    expect(exception.errorDetails).toEqual({
-      screenType: "consent",
-      indices: [0, 3],
-    });
-    expect(Object.isFrozen(exception.errorDetails?.["indices"])).toBe(true);
-  });
-});
-
-describe("LivenessFrameCountException", () => {
-  it("reports expected vs actual frame counts", () => {
-    const exception = new LivenessFrameCountException({
-      expected: 8,
-      actual: 3,
-    });
-
-    expect(exception.errorCode).toBe(
-      UseSmileIDErrorCode.Validation.ConstraintViolation,
-    );
-    expect(exception.message).toContain("8");
-    expect(exception.message).toContain("3");
-    expect(exception.errorDetails).toEqual({ expected: 8, actual: 3 });
-  });
-});
-
-describe("InvalidSelfieCaptureConfigException", () => {
-  it("omits the reason suffix and details when no reason is given", () => {
-    const exception = new InvalidSelfieCaptureConfigException();
-
-    expect(exception.errorCode).toBe(
-      UseSmileIDErrorCode.Builder.InvalidSelfieCaptureConfig,
-    );
-    expect(exception.message).toContain("configuration is missing");
-    expect(exception.errorDetails).toBeUndefined();
-  });
-
-  it("appends the reason and carries it in details when provided", () => {
-    const exception = new InvalidSelfieCaptureConfigException({
-      reason: "minConfidence out of range",
-    });
-
-    expect(exception.message).toContain("minConfidence out of range");
-    expect(exception.errorDetails).toEqual({
-      reason: "minConfidence out of range",
-    });
-  });
-});
-
-describe("InvalidMissingCaptureTypeException", () => {
-  it("carries the missing-capture-type code and an actionable fix", () => {
-    const exception = new InvalidMissingCaptureTypeException();
-
-    expect(exception).toBeInstanceOf(Error);
-    expect(exception.errorCode).toBe(
-      UseSmileIDErrorCode.Builder.MissingCaptureType,
-    );
-    expect(exception.message).toContain("captureType is missing");
-    expect(exception.suggestedFix).toContain("selfie or document");
-  });
-});

package/src/core/exception/__tests__/network_exception_mapper.test.ts

@@ -1,179 +0,0 @@
-import { AxiosError, type AxiosResponse } from "axios";
-import { describe, expect, it } from "vitest";
-
-import { UseSmileIDErrorCode } from "../use_smile_id_error_code";
-import {
-  mapAxiosError,
-  NetworkRequestBuildException,
-  NetworkServerException,
-  NetworkTimeoutException,
-  NetworkTransportException,
-  NetworkUnknownException,
-  UseSmileIDNetworkException,
-  type NetworkResponseParseException,
-} from "../use_smile_id_network_exception";
-
-/**
- * Locks down `mapAxiosError` — the canonical translator from axios's
- * catch-all `AxiosError` to the typed `UseSmileIDNetworkException`
- * hierarchy. A regression here would silently re-route every failure
- * through `NetworkUnknownException` and break partners' typed
- * `e instanceof NetworkTimeoutException` branches.
- */
-describe("mapAxiosError", () => {
-  it.each(["ERR_BAD_OPTION", "ERR_BAD_OPTION_VALUE", "ERR_INVALID_URL"])(
-    "AxiosError with code='%s' maps to NetworkRequestBuildException",
-    (code) => {
-      const axiosError = makeAxiosError({ code });
-      const mapped = mapAxiosError(axiosError);
-      expect(mapped).toBeInstanceOf(NetworkRequestBuildException);
-      expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.RequestFailed);
-    },
-  );
-
-  it("AxiosError with code='ECONNABORTED' maps to NetworkTimeoutException", () => {
-    const axiosError = makeAxiosError({ code: "ECONNABORTED" });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped).toBeInstanceOf(NetworkTimeoutException);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.Timeout);
-  });
-
-  it("AxiosError without response maps to NetworkTransportException", () => {
-    const axiosError = makeAxiosError({ code: "ERR_NETWORK" });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped).toBeInstanceOf(NetworkTransportException);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.ConnectionFailed);
-  });
-
-  it("AxiosError with 401 response maps to NetworkServerException(401)", () => {
-    const axiosError = makeAxiosError({
-      response: makeResponse(401, { code: "unauthorized" }),
-    });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped).toBeInstanceOf(NetworkServerException);
-    expect((mapped as NetworkServerException).statusCode).toBe(401);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.Unauthorized);
-  });
-
-  it("AxiosError with 403 maps to Forbidden", () => {
-    const axiosError = makeAxiosError({ response: makeResponse(403) });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.Forbidden);
-  });
-
-  it("AxiosError with 404 maps to NotFound", () => {
-    const axiosError = makeAxiosError({ response: makeResponse(404) });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.NotFound);
-  });
-
-  it("AxiosError with 429 maps to RateLimit", () => {
-    const axiosError = makeAxiosError({ response: makeResponse(429) });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.RateLimit);
-  });
-
-  it("AxiosError with 500 maps to ServerError", () => {
-    const axiosError = makeAxiosError({ response: makeResponse(500) });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.ServerError);
-  });
-
-  it("AxiosError with 503 maps to ServerError", () => {
-    const axiosError = makeAxiosError({ response: makeResponse(503) });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.ServerError);
-  });
-
-  it("AxiosError with 400 falls through to generic requestFailed", () => {
-    // 400 isn't specialised; the generic RequestFailed code applies.
-    const axiosError = makeAxiosError({ response: makeResponse(400) });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped.errorCode).toBe(UseSmileIDErrorCode.Network.RequestFailed);
-  });
-
-  it("AxiosError surfaces server-supplied message when present", () => {
-    const axiosError = makeAxiosError({
-      response: makeResponse(422, {
-        code: "VALIDATION_FAILED",
-        message: "id_number is required",
-      }),
-    });
-    const mapped = mapAxiosError(axiosError);
-    expect(mapped.message).toBe("id_number is required");
-  });
-
-  it("Generic Error maps to NetworkUnknownException with cause preserved", () => {
-    const cause = new Error("something weird");
-    const mapped = mapAxiosError(cause);
-    expect(mapped).toBeInstanceOf(NetworkUnknownException);
-    expect((mapped as NetworkUnknownException).cause).toBe(cause);
-    expect(mapped.message).toBe("something weird");
-  });
-
-  it("Non-Error throwable maps to NetworkUnknownException with string cause", () => {
-    const mapped = mapAxiosError("oops");
-    expect(mapped).toBeInstanceOf(NetworkUnknownException);
-    expect(mapped.message).toBe("oops");
-  });
-
-  it("Already-typed network exception passes through unchanged (idempotent)", () => {
-    const original = new NetworkServerException({ statusCode: 503 });
-    const mapped = mapAxiosError(original);
-    // Pass-through means the mapper can run inside retry / wrap paths
-    // without double-wrapping the typed exception.
-    expect(mapped).toBe(original);
-  });
-
-  it("every concrete subclass is catchable as UseSmileIDNetworkException", () => {
-    // The category catch (`instanceof UseSmileIDNetworkException`) is
-    // the partner-facing contract — every concrete subclass must
-    // extend it. Compile-time-typed cast keeps the assertion honest.
-    const exceptions: UseSmileIDNetworkException[] = [
-      new NetworkServerException({ statusCode: 500 }),
-      new NetworkTransportException(),
-      new NetworkTimeoutException(),
-      new NetworkUnknownException({}),
-    ];
-    for (const exception of exceptions) {
-      expect(exception).toBeInstanceOf(UseSmileIDNetworkException);
-    }
-    // ResponseParse is exported via `type` only to pacify Vite's SSR
-    // transformer; the runtime class is re-tested via its constructor
-    // signature elsewhere.
-    void (null as NetworkResponseParseException | null);
-  });
-});
-
-function makeAxiosError({
-  code,
-  response,
-}: {
-  readonly code?: string;
-  readonly response?: AxiosResponse;
-}): AxiosError {
-  const error = new AxiosError(
-    response
-      ? `Request failed with status ${response.status}`
-      : "network error",
-    code,
-    undefined,
-    undefined,
-    response,
-  );
-  return error;
-}
-
-function makeResponse(
-  status: number,
-  data?: { readonly code?: string; readonly message?: string },
-): AxiosResponse {
-  return {
-    status,
-    statusText: `HTTP ${status}`,
-    data: data ?? {},
-    headers: {},
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    config: { headers: {} as any },
-  };
-}

package/src/core/exception/agent_mode_with_enhanced_liveness_exception.ts

@@ -1,20 +0,0 @@
-import { UseSmileIDBuilderException } from "./use_smile_id_builder_exception";
-import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
-
-/**
- * Agent mode was combined with enhanced liveness. The head-turn challenge is
- * validated for front-camera capture only, so the two options are mutually
- * exclusive.
- */
-export class AgentModeWithEnhancedLivenessException extends UseSmileIDBuilderException {
-  readonly errorCode =
-    UseSmileIDErrorCode.Builder.AgentModeWithEnhancedLiveness;
-
-  constructor() {
-    super({
-      message: "allowAgentMode is not supported with enableEnhancedLiveness",
-      suggestedFix:
-        "Disable one of them inside selfie { }: allowAgentMode for rear-camera agent capture, or enableEnhancedLiveness for the head-turn challenge",
-    });
-  }
-}

package/src/core/exception/builder_validation_exception.ts

@@ -1,40 +0,0 @@
-import { UseSmileIDBuilderException } from "./use_smile_id_builder_exception";
-import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
-import type { ValidationStateInvalid } from "../../presentation/flow/validation/validation_state";
-
-/**
- * Wraps a failed validation state so partner code receiving the
- * failure via `onResult.failure` can inspect every rule that failed
- * — not only the first.
- *
- * Concrete usage:
- *
- * ```ts
- * b.onResult = (r) => {
- *   if (r.status === "failure" && r.error instanceof BuilderValidationException) {
- *     for (const issue of r.error.validationState.issues) {
- *       console.warn(issue.errorCode, issue.message);
- *     }
- *   }
- * };
- * ```
- *
- * The carried `validationState` is always the invalid branch of
- * `ValidationState` — `validationState.issues` is non-empty by
- * construction.
- */
-export class BuilderValidationException extends UseSmileIDBuilderException {
-  readonly errorCode = UseSmileIDErrorCode.Builder.ValidationError;
-  readonly validationState: ValidationStateInvalid;
-
-  constructor(validationState: ValidationStateInvalid) {
-    const issues = validationState.issues;
-    super({
-      message: `Flow validation failed: ${issues.map((i) => i.message).join(", ")}`,
-      suggestedFix:
-        issues[0]?.suggestedFix ??
-        "Inspect validationState.issues for the failed rules.",
-    });
-    this.validationState = validationState;
-  }
-}

package/src/core/exception/capture_validation_exceptions.ts

@@ -1,9 +0,0 @@
-/**
- * Re-export barrel for capture-configuration validation exceptions.
- * Each concrete class lives in its own file; this module keeps the
- * legacy import path stable.
- */
-export { AgentModeWithEnhancedLivenessException } from "./agent_mode_with_enhanced_liveness_exception";
-export { InvalidSelfieCaptureConfigException } from "./invalid_selfie_capture_config_exception";
-export { InvalidDocumentCaptureConfigException } from "./invalid_document_capture_config_exception";
-export { InvalidMissingCaptureTypeException } from "./invalid_missing_capture_type_exception";

package/src/core/exception/consent_validation_exceptions.ts

@@ -1,7 +0,0 @@
-/**
- * Re-export barrel for consent-configuration validation exceptions.
- * Each concrete class lives in its own file; this module keeps the
- * legacy import path stable.
- */
-export { InvalidConsentConfigException } from "./invalid_consent_config_exception";
-export { InvalidConsentInformationException } from "./invalid_consent_information_exception";

package/src/core/exception/duplicate_screen_type_exception.ts

@@ -1,22 +0,0 @@
-import { UseSmileIDBuilderException } from "./use_smile_id_builder_exception";
-import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
-
-/**
- * The `screens { }` block declared two screens of the same type. Each
- * `ScreenType` is allowed at most once per flow.
- */
-export class DuplicateScreenTypeException extends UseSmileIDBuilderException {
-  readonly errorCode = UseSmileIDErrorCode.Builder.DuplicateScreenType;
-
-  constructor(args: { screenType: string; indices: readonly number[] }) {
-    super({
-      message: `Duplicate screen type '${args.screenType}' found at indices: ${args.indices.join(", ")}`,
-      suggestedFix:
-        "Each screen type must be unique. Remove the duplicate or change its type.",
-      errorDetails: {
-        screenType: args.screenType,
-        indices: Object.freeze([...args.indices]),
-      },
-    });
-  }
-}

package/src/core/exception/empty_screens_block_exception.ts

@@ -1,19 +0,0 @@
-import { UseSmileIDBuilderException } from "./use_smile_id_builder_exception";
-import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
-
-/**
- * The `screens { }` block was opened but no screens were declared.
- * Surfaced when partner code calls `b.screens(() => ...)` with an
- * empty closure body.
- */
-export class EmptyScreensBlockException extends UseSmileIDBuilderException {
-  readonly errorCode = UseSmileIDErrorCode.Builder.EmptyScreensBlock;
-
-  constructor() {
-    super({
-      message: "The screens { } block is empty — no screens were added",
-      suggestedFix:
-        "Add screens inside the screens { } block using one of: instructions { }, capture { }, preview { }, or processing { }",
-    });
-  }
-}

package/src/core/exception/flow_exceptions.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  ConsentDeniedException,
-  ProcessingCancelledException,
-} from "./flow_exceptions";
-import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
-import { UseSmileIDException } from "./use_smile_id_exception";
-import { UseSmileIDGeneralException } from "./use_smile_id_general_exception";
-
-describe("ConsentDeniedException", () => {
-  it("carries the General.OperationFailed code and the denial timestamp", () => {
-    const error = new ConsentDeniedException({ timestamp: 1_700_000_000_000 });
-    expect(error.errorCode).toBe(UseSmileIDErrorCode.General.OperationFailed);
-    expect(error.message).toBe("User denied consent");
-    expect(error.errorDetails).toEqual({ timestamp: 1_700_000_000_000 });
-  });
-
-  it("is an instance of the general + root exception bases", () => {
-    const error = new ConsentDeniedException({ timestamp: 1 });
-    expect(error).toBeInstanceOf(UseSmileIDGeneralException);
-    expect(error).toBeInstanceOf(UseSmileIDException);
-    expect(error).toBeInstanceOf(Error);
-  });
-});
-
-describe("ProcessingCancelledException", () => {
-  it("carries the General.OperationFailed code", () => {
-    const error = new ProcessingCancelledException();
-    expect(error.errorCode).toBe(UseSmileIDErrorCode.General.OperationFailed);
-    expect(error.message).toBe("Processing was cancelled");
-  });
-
-  it("is an instance of the general + root exception bases", () => {
-    const error = new ProcessingCancelledException();
-    expect(error).toBeInstanceOf(UseSmileIDGeneralException);
-    expect(error).toBeInstanceOf(UseSmileIDException);
-    expect(error).toBeInstanceOf(Error);
-  });
-
-  it("carries an underlying cause when one is supplied", () => {
-    const underlying = new Error("upload aborted");
-    const error = new ProcessingCancelledException({ cause: underlying });
-    expect(error.cause).toBe(underlying);
-  });
-
-  it("leaves cause unset when none is supplied", () => {
-    expect(new ProcessingCancelledException().cause).toBeUndefined();
-  });
-});

package/src/core/exception/flow_exceptions.ts

@@ -1,43 +0,0 @@
-import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
-import { UseSmileIDGeneralException } from "./use_smile_id_general_exception";
-
-/**
- * The user declined the consent notice on the consent screen.
- *
- * Surfaced through `onResult.failure` so partners can distinguish a
- * deliberate consent denial from other flow failures. Carries the
- * wall-clock `timestamp` (epoch ms) of the denial, mirroring the
- * native SDKs' `ConsentDeniedException`.
- */
-export class ConsentDeniedException extends UseSmileIDGeneralException {
-  readonly errorCode = UseSmileIDErrorCode.General.OperationFailed;
-
-  constructor(args: { timestamp: number }) {
-    super({
-      message: "User denied consent",
-      suggestedFix:
-        "The user declined the consent notice; no further action is required.",
-      errorDetails: { timestamp: args.timestamp },
-    });
-  }
-}
-
-/**
- * The user exited the processing screen before submission completed.
- *
- * Surfaced through `onResult.failure` so partners can distinguish a
- * user-initiated cancellation from a submission error, mirroring the
- * native SDKs' `ProcessingCancelledException`. An optional `cause` carries a submission failure that preceded the exit.
- */
-export class ProcessingCancelledException extends UseSmileIDGeneralException {
-  readonly errorCode = UseSmileIDErrorCode.General.OperationFailed;
-
-  constructor(args: { cause?: unknown } = {}) {
-    super({
-      message: "Processing was cancelled",
-      suggestedFix:
-        "The user exited the processing screen before submission completed.",
-      ...(args.cause !== undefined ? { cause: args.cause } : {}),
-    });
-  }
-}