@smileid/usesmileid 12.0.0-beta01

package/src/camera/use_smile_id_frame_stream.ts

@@ -0,0 +1,189 @@
+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__/network_exception_mapper.test.ts

@@ -0,0 +1,179 @@
+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/builder_validation_exception.ts

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

@@ -0,0 +1,8 @@
+/**
+ * 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 { 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

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

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

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

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

package/src/core/exception/flow_exceptions.ts

@@ -0,0 +1,42 @@
+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`.
+ */
+export class ProcessingCancelledException extends UseSmileIDGeneralException {
+  readonly errorCode = UseSmileIDErrorCode.General.OperationFailed;
+
+  constructor() {
+    super({
+      message: "Processing was cancelled",
+      suggestedFix:
+        "The user exited the processing screen before submission completed.",
+    });
+  }
+}

package/src/core/exception/index.ts

@@ -0,0 +1,73 @@
+/**
+ * Barrel for the SDK's exception hierarchy. Every concrete class
+ * (Builder/Validation, Camera, Network, Attestation, General) lives
+ * in its own file under this directory; this barrel exposes the
+ * complete typed set with a single import surface.
+ *
+ * The legacy cluster files (`screen_config_validation_exceptions.ts`,
+ * `capture_validation_exceptions.ts`, `consent_validation_exceptions.ts`,
+ * `job_validation_exceptions.ts`) continue to re-export their original
+ * class lists so partner code that deep-imports them keeps compiling.
+ */
+
+// Severity tier carried by every exception.
+export { IssueSeverity } from "./issue_severity";
+
+// Stable error-code registry — UPPER_SNAKE_CASE wire strings grouped
+// by category for typed switches.
+export { UseSmileIDErrorCode } from "./use_smile_id_error_code";
+
+// Hierarchy roots and category bases.
+export { UseSmileIDException } from "./use_smile_id_exception";
+export { UseSmileIDValidationException } from "./use_smile_id_validation_exception";
+export { UseSmileIDBuilderException } from "./use_smile_id_builder_exception";
+export { UseSmileIDCameraException } from "./use_smile_id_camera_exception";
+export { UseSmileIDNetworkException } from "./use_smile_id_network_exception";
+export { UseSmileIDAttestationException } from "./use_smile_id_attestation_exception";
+export { UseSmileIDGeneralException } from "./use_smile_id_general_exception";
+
+// Aggregate failure wrapper surfaced via `onResult.failure`.
+export { BuilderValidationException } from "./builder_validation_exception";
+
+// Flow-control failures surfaced via `onResult.failure` (consent denial,
+// processing cancellation).
+export {
+  ConsentDeniedException,
+  ProcessingCancelledException,
+} from "./flow_exceptions";
+
+// Screen-config validation (`screens { }` block).
+export { EmptyScreensBlockException } from "./empty_screens_block_exception";
+export { InvalidScreenOrderException } from "./invalid_screen_order_exception";
+export { MissingCaptureForPreviewException } from "./missing_capture_for_preview_exception";
+export { DuplicateScreenTypeException } from "./duplicate_screen_type_exception";
+
+// Capture-config validation (`capture { }` block).
+export { InvalidSelfieCaptureConfigException } from "./invalid_selfie_capture_config_exception";
+export { InvalidDocumentCaptureConfigException } from "./invalid_document_capture_config_exception";
+export { InvalidMissingCaptureTypeException } from "./invalid_missing_capture_type_exception";
+
+// Consent-config + ConsentInformation payload validation.
+export { InvalidConsentConfigException } from "./invalid_consent_config_exception";
+export { InvalidConsentInformationException } from "./invalid_consent_information_exception";
+
+// Job / network / ML-block validation.
+export { MissingMLConfigurationBlockException } from "./missing_ml_configuration_block_exception";
+export { MissingNetworkConfigurationBlockException } from "./missing_network_configuration_block_exception";
+export { MissingPartnerConfigException } from "./missing_partner_config_exception";
+export { LivenessFrameCountException } from "./liveness_frame_count_exception";
+export { MissingJobTypeException } from "./missing_job_type_exception";
+export { MissingRequiredFieldException } from "./missing_required_field_exception";
+export { InvalidJobTypeScreenConfigException } from "./invalid_job_type_screen_config_exception";
+export { InvalidFieldValueException } from "./invalid_field_value_exception";
+
+// Network mapping helpers + concrete network subclasses.
+export {
+  NetworkServerException,
+  NetworkTransportException,
+  NetworkTimeoutException,
+  NetworkResponseParseException,
+  NetworkRequestBuildException,
+  NetworkUnknownException,
+  mapAxiosError,
+} from "./use_smile_id_network_exception";

package/src/core/exception/invalid_consent_config_exception.ts

@@ -0,0 +1,20 @@
+import { UseSmileIDBuilderException } from "./use_smile_id_builder_exception";
+import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
+
+/**
+ * The consent screen is configured but one of its required fields is
+ * missing or invalid. The optional `reason` is used as the message
+ * when supplied so partners see the specific field that failed.
+ */
+export class InvalidConsentConfigException extends UseSmileIDBuilderException {
+  readonly errorCode = UseSmileIDErrorCode.Builder.InvalidConsentConfig;
+
+  constructor(args: { reason?: string } = {}) {
+    super({
+      message: args.reason ?? "Consent configuration is invalid",
+      suggestedFix:
+        "Ensure the consent screen has all required fields: partnerName, partnerPrivacyPolicyUrl, and partnerIcon",
+      errorDetails: args.reason ? { reason: args.reason } : undefined,
+    });
+  }
+}

package/src/core/exception/invalid_consent_information_exception.ts

@@ -0,0 +1,21 @@
+import { UseSmileIDBuilderException } from "./use_smile_id_builder_exception";
+import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
+
+/**
+ * A `ConsentInformation` payload failed validation — e.g. `granted`
+ * is `false`, `grantedAt` is blank, or `noticePrivacyPolicyUrl` is
+ * missing. The `detail` string carries the specific field-level
+ * complaint and is appended to the message prefix.
+ */
+export class InvalidConsentInformationException extends UseSmileIDBuilderException {
+  readonly errorCode = UseSmileIDErrorCode.Builder.InvalidConsentInformation;
+
+  constructor(args: { detail: string }) {
+    super({
+      message: `Invalid consent information: ${args.detail}`,
+      suggestedFix:
+        "Ensure ConsentInformation has granted=true, a non-blank grantedAt timestamp, a non-blank noticeLanguage, and a non-null noticePrivacyPolicyUrl.",
+      errorDetails: { detail: args.detail },
+    });
+  }
+}