@smileid/usesmileid 12.0.0 → 12.0.1

package/src/data/api/interceptors/__tests__/gzip_interceptor.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import axios, { AxiosHeaders, type InternalAxiosRequestConfig } from "axios";
+
+import { createGzipInterceptor } from "../gzip_interceptor";
+
+/**
+ * Pins `createGzipInterceptor`'s wire shape: it stamps `Accept-Encoding: gzip` on every request
+ * (never reading `config.data`), leaves the body unmodified (no compression, no Content-Type/
+ * Length), never sets `Content-Encoding`, and overwrites any existing `Accept-Encoding`.
+ */
+describe("createGzipInterceptor", () => {
+  function attachAndRun(
+    config: InternalAxiosRequestConfig,
+  ): Promise<InternalAxiosRequestConfig> {
+    const client = axios.create();
+    createGzipInterceptor().attach(client);
+    const handlers = (
+      client.interceptors.request as unknown as {
+        handlers: {
+          fulfilled?: (
+            cfg: InternalAxiosRequestConfig,
+          ) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+        }[];
+      }
+    ).handlers;
+    const fulfilled = handlers[handlers.length - 1]?.fulfilled;
+    if (!fulfilled) throw new Error("gzip interceptor did not register");
+    return Promise.resolve(fulfilled(config));
+  }
+
+  it("stamps Accept-Encoding: gzip on a bodyless request", async () => {
+    const result = await attachAndRun({
+      headers: new AxiosHeaders(),
+    } as InternalAxiosRequestConfig);
+
+    expect(result.headers.get("Accept-Encoding")).toBe("gzip");
+    expect(result.data).toBeUndefined();
+  });
+
+  it("stamps the header without touching a JSON string body", async () => {
+    const result = await attachAndRun({
+      headers: new AxiosHeaders(),
+      data: '{"hello":"world"}',
+    } as InternalAxiosRequestConfig);
+
+    expect(result.headers.get("Accept-Encoding")).toBe("gzip");
+    // The body is not compressed or otherwise transformed.
+    expect(result.data).toBe('{"hello":"world"}');
+    expect(result.headers.get("Content-Type")).toBeUndefined();
+  });
+
+  it("stamps the header without touching a multipart FormData body", async () => {
+    // A minimal FormData-like stand-in; the interceptor never inspects
+    // `config.data`'s shape, so this is enough to prove pass-through.
+    const formData = { getParts: () => [] };
+    const result = await attachAndRun({
+      headers: new AxiosHeaders(),
+      data: formData,
+    } as unknown as InternalAxiosRequestConfig);
+
+    expect(result.headers.get("Accept-Encoding")).toBe("gzip");
+    expect(result.data).toBe(formData);
+    expect(result.headers.get("Content-Type")).toBeUndefined();
+    expect(result.headers.get("Content-Length")).toBeUndefined();
+  });
+
+  it("never stamps Content-Encoding — the request body itself is never compressed", async () => {
+    const result = await attachAndRun({
+      headers: new AxiosHeaders(),
+      data: '{"hello":"world"}',
+    } as InternalAxiosRequestConfig);
+
+    expect(result.headers.get("Content-Encoding")).toBeUndefined();
+  });
+
+  it("overwrites an Accept-Encoding value set by an earlier interceptor", async () => {
+    const result = await attachAndRun({
+      headers: new AxiosHeaders({ "Accept-Encoding": "identity" }),
+    } as InternalAxiosRequestConfig);
+
+    expect(result.headers.get("Accept-Encoding")).toBe("gzip");
+  });
+});

package/src/data/api/interceptors/smile_auth_interceptor.ts

@@ -1,5 +1,5 @@
 import type { AxiosInstance, InternalAxiosRequestConfig } from "axios";
-import { Platform } from "react-native";
+import { sourceSdkIdentifier } from "@smileid/usesmileid_bridge";
 
 import type { PartnerConfig } from "../../../core/models/network_config";
 import { currentRequestTimestamp } from "../../security/request_timestamp";
@@ -26,22 +26,7 @@ import type { TokenHolder } from "../auth/token_holder";
  * by the next outgoing request.
  */
 
-const SDK_VERSION = "12.0.0";
-
-/**
- * Source-SDK identifier, suffixed with the runtime platform so the server can
- * attribute the request and resolve the matching per-SDK signing secret.
- */
-function sourceSdk(): string {
-  switch (Platform.OS) {
-    case "android":
-      return "react-native-expo (android)";
-    case "ios":
-      return "react-native-expo (iOS)";
-    default:
-      return "react-native-expo";
-  }
-}
+const SDK_VERSION = "12.0.1";
 
 export type SmileAuthInterceptorOptions = {
   readonly partnerConfig: PartnerConfig;
@@ -73,7 +58,7 @@ export class SmileAuthInterceptor {
     config: InternalAxiosRequestConfig,
   ): Promise<InternalAxiosRequestConfig> {
     config.headers.set("smileid-token", this._tokenHolder.current);
-    config.headers.set("smileid-source-sdk", sourceSdk());
+    config.headers.set("smileid-source-sdk", sourceSdkIdentifier());
     config.headers.set("smileid-source-sdk-version", SDK_VERSION);
     config.headers.set("smileid-partner-id", this._partnerConfig.partnerId);
     if (this._partnerConfig.callbackUrl) {

package/src/data/compression/__tests__/payload_compressor_real_jpeg.test.ts

@@ -125,7 +125,9 @@ describe("PayloadCompressor with real JPEG bytes", () => {
 
   it(
     "compresses an inflated selfie+liveness bundle under the caps and keeps files decodable",
-    { timeout: 120_000 },
+    // Real JPEG (re)compression is CPU-heavy; under v8 coverage instrumentation on CI it runs
+    // ~2.5x slower (~120s), so allow generous headroom over the ~120s per-test CI runtime.
+    { timeout: 300_000 },
     async () => {
       const selfieUri = "file:///capture/selfie.jpg";
       const livenessUri = "file:///capture/liveness.jpg";
@@ -172,7 +174,9 @@ describe("PayloadCompressor with real JPEG bytes", () => {
 
   it(
     "compresses a document-heavy bundle back-first and lands under the guarantee caps",
-    { timeout: 120_000 },
+    // Real JPEG (re)compression is CPU-heavy; under v8 coverage instrumentation on CI it runs
+    // ~2.5x slower (~120s), so allow generous headroom over the ~120s per-test CI runtime.
+    { timeout: 300_000 },
     async () => {
       const frontUri = "file:///capture/front.jpg";
       const backUri = "file:///capture/back.jpg";

package/src/data/dsl/builder/__tests__/config_builders.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+
+import { CacheConfigBuilder } from "../cache_config_builder";
+import { RetryConfigBuilder, RetryStrategy } from "../retry_config_builder";
+
+/** Retry/cache DSL builders: pin the documented defaults, frozen output, and overrides. */
+describe("RetryConfigBuilder", () => {
+  it("builds a frozen config with the documented defaults", () => {
+    const config = new RetryConfigBuilder().build();
+
+    expect(config).toEqual({
+      maxAttempts: 1,
+      strategy: RetryStrategy.none,
+      initialDelay: 1,
+      multiplier: 2,
+      maxDelay: 32,
+      jitter: 0.2,
+      fixedDelay: 1,
+    });
+    expect(Object.isFrozen(config)).toBe(true);
+  });
+
+  it("forces maxAttempts to 1 for none, whatever the field says", () => {
+    const builder = new RetryConfigBuilder();
+    builder.maxAttempts = 5;
+
+    expect(builder.build().maxAttempts).toBe(1);
+  });
+
+  it("applies the attempt budget once a strategy opts in", () => {
+    const builder = new RetryConfigBuilder();
+    builder.strategy = RetryStrategy.exponential;
+
+    expect(builder.build().maxAttempts).toBe(3);
+  });
+
+  it("carries overridden fields through build()", () => {
+    const builder = new RetryConfigBuilder();
+    builder.maxAttempts = 5;
+    builder.strategy = RetryStrategy.fixed;
+    builder.fixedDelay = 4;
+
+    const config = builder.build();
+
+    expect(config.maxAttempts).toBe(5);
+    expect(config.strategy).toBe(RetryStrategy.fixed);
+    expect(config.fixedDelay).toBe(4);
+  });
+});
+
+describe("CacheConfigBuilder", () => {
+  it("defaults to enabled with a 50 MB ceiling", () => {
+    const config = new CacheConfigBuilder().build();
+
+    expect(config).toEqual({ enabled: true, maxSize: 50 * 1024 * 1024 });
+    expect(Object.isFrozen(config)).toBe(true);
+  });
+
+  it("megabytes() converts MB to bytes", () => {
+    expect(new CacheConfigBuilder().megabytes(10)).toBe(10 * 1024 * 1024);
+  });
+});

package/src/data/dsl/builder/retry_config_builder.ts

@@ -8,16 +8,16 @@ export { RetryStrategy };
 /**
  * DSL builder for request retry behaviour.
  *
- * Defaults to exponential backoff with 3 attempts, 1 s initial delay,
- * 32 s ceiling, ±20% jitter. `fixedDelay` is honoured only when
- * `strategy = RetryStrategy.fixed`.
+ * Defaults to no retry. Set `strategy` to opt in, and the remaining fields
+ * then apply: 3 attempts, 1 s initial delay, 32 s ceiling, ±20% jitter.
+ * `fixedDelay` is honoured only when `strategy = RetryStrategy.fixed`.
  */
 export class RetryConfigBuilder {
-  /** Maximum number of attempts per request, including the first. */
+  /** Attempts per request including the first; applies once `strategy` opts in. */
   maxAttempts = 3;
 
   /** Backoff strategy between attempts: exponential, fixed, or none. */
-  strategy: RetryStrategy = RetryStrategy.exponential;
+  strategy: RetryStrategy = RetryStrategy.none;
 
   /** Delay before the first retry, in seconds (exponential strategy). */
   initialDelay = 1;
@@ -45,7 +45,7 @@ export class RetryConfigBuilder {
 
   build(): RetryConfig {
     return Object.freeze({
-      maxAttempts: this.maxAttempts,
+      maxAttempts: this.strategy === RetryStrategy.none ? 1 : this.maxAttempts,
       strategy: this.strategy,
       initialDelay: this.initialDelay,
       multiplier: this.multiplier,

package/src/data/factory/__tests__/retry_gzip_mac_composition.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import {
+  AxiosError,
+  type AxiosResponse,
+  type InternalAxiosRequestConfig,
+} from "axios";
+
+import { JobType } from "../../../core/models/job_type";
+import type { NetworkConfig } from "../../../core/models/network_config";
+import { makeNetworkingFactory } from "../networking_factory";
+import { SmileIDCryptoManager } from "../../security/smile_id_crypto_manager";
+import {
+  REQUEST_MAC_HEADER,
+  REQUEST_MAC_OPT_IN_KEY,
+  REQUEST_TIMESTAMP_HEADER,
+} from "../../api/interceptors/smile_request_mac_interceptor";
+
+/**
+ * Standing-guard composition test for token-refresh × gzip × request-MAC on a
+ * 401 → refresh → retry. `TokenRefreshInterceptor` re-issues the config, re-running the whole
+ * chain (auth re-stamps the token, MAC re-signs, gzip re-stamps `Accept-Encoding`). If a future
+ * change made gzip replace `config.data` with compressed bytes, the MAC would sign a body the
+ * canonicalizer no longer sees as FormData → `{}`. Pins the retried MAC against the uncompressed
+ * body so that regression fails loud.
+ */
+describe("token-refresh x gzip x request-MAC composition", () => {
+  const initialToken = "token-1";
+  const refreshedToken = "token-2";
+  const signingSecret = "test-signing-secret";
+  const cryptoManager = new SmileIDCryptoManager(signingSecret);
+
+  type FormDataPart = { fieldName: string; string?: string; uri?: string };
+
+  /**
+   * Stand-in for RN's `FormData`. Besides `getParts()` (what the canonicalizer reads), it
+   * satisfies axios's `isFormData()` (`Symbol.toStringTag` + `append`) so axios's request
+   * transform leaves it untouched instead of JSON-stringifying it.
+   */
+  class FakeFormData {
+    constructor(private readonly parts: readonly FormDataPart[]) {}
+    get [Symbol.toStringTag](): string {
+      return "FormData";
+    }
+    append(): void {
+      /* not exercised — only presence is checked by axios's isFormData() */
+    }
+    getParts(): readonly FormDataPart[] {
+      return this.parts;
+    }
+  }
+
+  function submissionBody(): FakeFormData {
+    return new FakeFormData([
+      { fieldName: "country", string: "NG" },
+      { fieldName: "partner_params", string: '{"flow":"enhanced"}' },
+      {
+        fieldName: "selfie_image",
+        uri: "data:application/octet-stream;base64,c2VsZmll",
+      },
+    ]);
+  }
+
+  /** Flattens the observed AxiosHeaders to a lower-cased record, matching how
+   *  RequestCanonicalizer lower-cases header names before signing. */
+  function headersRecord(
+    headers: InternalAxiosRequestConfig["headers"],
+  ): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const [key, value] of Object.entries(
+      headers as unknown as Record<string, unknown>,
+    )) {
+      if (value != null) out[key.toLowerCase()] = String(value);
+    }
+    return out;
+  }
+
+  function makeConfig(): NetworkConfig {
+    return {
+      config: {
+        jobType: JobType.smartSelfieEnrollment,
+        token: initialToken,
+        onTokenExpired: async () => refreshedToken,
+        partnerConfig: {
+          partnerId: "partner-1",
+          callbackUrl: "https://partner.example.com/cb",
+          useSandbox: true,
+        },
+      },
+    };
+  }
+
+  it("signs the refresh-retried request's MAC over the uncompressed submission body", async () => {
+    const requestsSeen: InternalAxiosRequestConfig[] = [];
+    const { client } = makeNetworkingFactory(makeConfig(), () => signingSecret);
+
+    // 401 first, 200 on the retry. A custom adapter bypasses axios's validateStatus, so it
+    // must reject non-2xx itself for TokenRefreshInterceptor's error handler to see it.
+    client.defaults.adapter = (
+      requestConfig: InternalAxiosRequestConfig,
+    ): Promise<AxiosResponse> => {
+      requestsSeen.push(requestConfig);
+      const isFirstCall = requestsSeen.length === 1;
+      const response: AxiosResponse = {
+        status: isFirstCall ? 401 : 200,
+        statusText: isFirstCall ? "Unauthorized" : "OK",
+        data: isFirstCall ? { error: "unauthorized" } : { jobId: "job-1" },
+        headers: {},
+        config: requestConfig,
+      };
+      if (isFirstCall) {
+        return Promise.reject(
+          new AxiosError(
+            "Request failed with status code 401",
+            AxiosError.ERR_BAD_REQUEST,
+            requestConfig,
+            undefined,
+            response,
+          ),
+        );
+      }
+      return Promise.resolve(response);
+    };
+
+    const body = submissionBody();
+    const response = await client.post("/v3/enhanced_kyc", body, {
+      [REQUEST_MAC_OPT_IN_KEY]: true,
+    } as Partial<InternalAxiosRequestConfig>);
+
+    expect(response.status).toBe(200);
+    expect(requestsSeen).toHaveLength(2);
+
+    const retried = requestsSeen[1]!;
+    const retriedHeaders = headersRecord(retried.headers);
+
+    expect(retriedHeaders["smileid-token"]).toBe(refreshedToken);
+    expect(retriedHeaders["accept-encoding"]).toBe("gzip");
+    // gzip is hint-only — it never compresses the body, so no Content-Encoding claim.
+    expect(retriedHeaders["content-encoding"]).toBeUndefined();
+
+    const retriedMac = retriedHeaders[REQUEST_MAC_HEADER];
+    const retriedTimestamp = retriedHeaders[REQUEST_TIMESTAMP_HEADER];
+    expect(retriedMac).toBeDefined();
+    expect(retriedTimestamp).toBeDefined();
+
+    // Recompute the server-verified MAC over the retried headers and the real body — gzip
+    // is hint-only (never replaces config.data), so `body` is the bytes that shipped.
+    const expectedMac = await cryptoManager.sign(
+      retriedTimestamp!,
+      retriedHeaders,
+      body,
+    );
+    expect(retriedMac).toBe(expectedMac);
+
+    // And it must not match a MAC computed against an empty body — the
+    // signature of the regression this test guards against.
+    const emptyBodyMac = await cryptoManager.sign(
+      retriedTimestamp!,
+      retriedHeaders,
+      undefined,
+    );
+    expect(retriedMac).not.toBe(emptyBodyMac);
+  });
+});

package/src/data/factory/__tests__/signed_job_submission_headers.test.ts

@@ -36,7 +36,7 @@ function makeBaseConfig(): NetworkConfig {
 }
 
 const metadata = new UseSmileIDMetadata({
-  sdkVersion: "12.0.0",
+  sdkVersion: "12.0.1",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",

package/src/data/repository/__tests__/network_retries.test.ts

@@ -34,7 +34,7 @@ const CONSENT: ConsentInformation = Object.freeze({
 });
 
 const METADATA = new UseSmileIDMetadata({
-  sdkVersion: "12.0.0",
+  sdkVersion: "12.0.1",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",

package/src/data/repository/__tests__/use_smile_id_repository.test.ts

@@ -51,7 +51,7 @@ const CONSENT: ConsentInformation = Object.freeze({
 // BVN path short-circuits before the API serializes it, but the field
 // is required on `BaseJobRequest` so the fixture must supply one.
 const METADATA = new UseSmileIDMetadata({
-  sdkVersion: "12.0.0",
+  sdkVersion: "12.0.1",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",

package/src/data/security/__tests__/request_canonicalizer.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it } from "vitest";
+
+import { RequestCanonicalizer } from "../request_canonicalizer";
+import { SmileIDCryptoManager } from "../smile_id_crypto_manager";
+
+/**
+ * Golden-vector suite for `RequestCanonicalizer`: pins the exact canonical bytes and the resulting
+ * `smileid-request-mac` for a fixed key across the shapes `canonicalize()` distinguishes. This
+ * SDK's own contract with the server, not a cross-SDK guarantee.
+ */
+const TIMESTAMP = "1700000000000";
+const SIGNING_SECRET = "golden-vector-secret";
+const cryptoManager = new SmileIDCryptoManager(SIGNING_SECRET);
+
+const BASE_HEADERS = {
+  "smileid-token": "golden-token",
+  "smileid-request-timestamp": TIMESTAMP,
+};
+
+type FormDataPart = { fieldName: string; string?: string; uri?: string };
+
+/** Minimal stand-in for React Native's `FormData` (only `getParts` is read). */
+function formData(parts: readonly FormDataPart[]) {
+  return { getParts: () => parts };
+}
+
+function decode(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString("utf-8");
+}
+
+const MULTIPART_BODY = formData([
+  { fieldName: "country", string: "NG" },
+  { fieldName: "allow_new_enroll", string: "true" },
+  { fieldName: "partner_params", string: '{"job_id":"j1"}' },
+  {
+    fieldName: "selfie_image",
+    uri: "data:application/octet-stream;base64,c2VsZmll",
+  },
+]);
+
+// Same logical fields as MULTIPART_BODY, in reverse part order.
+const MULTIPART_BODY_REORDERED = formData([
+  {
+    fieldName: "selfie_image",
+    uri: "data:application/octet-stream;base64,c2VsZmll",
+  },
+  { fieldName: "partner_params", string: '{"job_id":"j1"}' },
+  { fieldName: "allow_new_enroll", string: "true" },
+  { fieldName: "country", string: "NG" },
+]);
+
+const MIXED_CASE_HEADERS = {
+  "Smileid-Token": "golden-token",
+  "SMILEID-REQUEST-TIMESTAMP": TIMESTAMP,
+};
+
+describe("RequestCanonicalizer golden vectors", () => {
+  it("(a) canonicalizes a bodyless request to the signed headers + `{}`", async () => {
+    const bytes = await RequestCanonicalizer.canonicalize(
+      BASE_HEADERS,
+      undefined,
+    );
+    expect(decode(bytes)).toBe(
+      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}{}',
+    );
+    expect(await cryptoManager.sign(TIMESTAMP, BASE_HEADERS, undefined)).toBe(
+      "qikeRL0jNa7bZKUZdoN7tY30VvVy4ol/hcMdyg4PU4w=",
+    );
+  });
+
+  it("(b) canonicalizes a raw JSON-string body the same as a bodyless request — only FormData-shaped bodies are reconstructed", async () => {
+    const bytes = await RequestCanonicalizer.canonicalize(
+      BASE_HEADERS,
+      '{"hello":"world"}',
+    );
+    // Same canonical bytes as case (a): a JSON string isn't FormData-like,
+    // so canonicalBody() falls through to the same `{}` as no body at all.
+    expect(decode(bytes)).toBe(
+      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}{}',
+    );
+    expect(
+      await cryptoManager.sign(TIMESTAMP, BASE_HEADERS, '{"hello":"world"}'),
+    ).toBe("qikeRL0jNa7bZKUZdoN7tY30VvVy4ol/hcMdyg4PU4w=");
+  });
+
+  it("(c) canonicalizes a multipart FormData body: scalar, boolean-coerced, JSON, and file parts", async () => {
+    const bytes = await RequestCanonicalizer.canonicalize(
+      BASE_HEADERS,
+      MULTIPART_BODY,
+    );
+    expect(decode(bytes)).toBe(
+      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}' +
+        '{"allow_new_enroll":true,"country":"NG","partner_params":{"job_id":"j1"},"selfie_image":"c2VsZmll"}',
+    );
+    expect(
+      await cryptoManager.sign(TIMESTAMP, BASE_HEADERS, MULTIPART_BODY),
+    ).toBe("eNJqKR45aNiou4JM0yVRNYrTdhfg1VblWvsbrRndoLQ=");
+  });
+
+  it("(d) part ordering does not change the canonical bytes or the MAC", async () => {
+    const bytes = await RequestCanonicalizer.canonicalize(
+      BASE_HEADERS,
+      MULTIPART_BODY_REORDERED,
+    );
+    expect(decode(bytes)).toBe(
+      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}' +
+        '{"allow_new_enroll":true,"country":"NG","partner_params":{"job_id":"j1"},"selfie_image":"c2VsZmll"}',
+    );
+    expect(
+      await cryptoManager.sign(
+        TIMESTAMP,
+        BASE_HEADERS,
+        MULTIPART_BODY_REORDERED,
+      ),
+    ).toBe("eNJqKR45aNiou4JM0yVRNYrTdhfg1VblWvsbrRndoLQ=");
+  });
+
+  it("(e) header key casing does not change the canonical bytes or the MAC", async () => {
+    const bytes = await RequestCanonicalizer.canonicalize(
+      MIXED_CASE_HEADERS,
+      undefined,
+    );
+    // Identical to case (a): canonicalHeaders() lower-cases every header
+    // name before signing, so casing at the call site is not observable.
+    expect(decode(bytes)).toBe(
+      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}{}',
+    );
+    expect(
+      await cryptoManager.sign(TIMESTAMP, MIXED_CASE_HEADERS, undefined),
+    ).toBe("qikeRL0jNa7bZKUZdoN7tY30VvVy4ol/hcMdyg4PU4w=");
+  });
+});

package/src/data/smile_id_urls.ts

@@ -5,7 +5,7 @@
  * kept so the production host can diverge without touching call sites.
  */
 export const SmileIDUrls = {
-  sandbox: "https://devapi.smileidentity.com/",
+  sandbox: "https://testapi.smileidentity.com/",
   production: "https://api.smileidentity.com/",
   forConfig(useSandbox: boolean): string {
     return useSandbox ? this.sandbox : this.production;

package/src/data/util/__tests__/retry_util.test.ts

@@ -154,4 +154,29 @@ describe("withRetry", () => {
     });
     expect(block).toHaveBeenCalledTimes(3); // maxAttempts
   });
+
+  it('strategy="none" never retries, even with an attempt budget', async () => {
+    // A config can carry both; the strategy wins.
+    const block = vi.fn().mockRejectedValue(makeAxiosError(503));
+    const config: RetryConfig = {
+      ...exponentialConfig,
+      strategy: RetryStrategy.none,
+    };
+
+    await expect(withRetry(config, block)).rejects.toMatchObject({
+      response: { status: 503 },
+    });
+    expect(block).toHaveBeenCalledTimes(1);
+  });
+
+  it("makes one attempt and surfaces the real error when maxAttempts is 0", async () => {
+    // `attempt < 0` never ran the body, so the old code rejected with `undefined`.
+    const block = vi.fn().mockRejectedValue(makeAxiosError(503));
+    const config: RetryConfig = { ...exponentialConfig, maxAttempts: 0 };
+
+    await expect(withRetry(config, block)).rejects.toMatchObject({
+      response: { status: 503 },
+    });
+    expect(block).toHaveBeenCalledTimes(1);
+  });
 });

package/src/data/util/retry_util.ts

@@ -1,5 +1,8 @@
 import { isAxiosError } from "axios";
-import type { RetryConfig } from "../../core/models/network_config";
+import {
+  RetryStrategy,
+  type RetryConfig,
+} from "../../core/models/network_config";
 
 /**
  * Retry helper. Retries `block` until success or `maxAttempts`
@@ -15,6 +18,11 @@ export async function withRetry<T>(
   config: RetryConfig,
   block: (attempt: number) => Promise<T>,
 ): Promise<T> {
+  // Without this the loop below never runs and rejects with `undefined`.
+  if (config.strategy === RetryStrategy.none || config.maxAttempts <= 1) {
+    return block(0);
+  }
+
   let lastError: unknown;
   for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
     try {

package/src/index.ts

@@ -27,6 +27,7 @@ export {
 // subclass holds a stable `errorCode` and `severity` so partner
 // tooling can pivot on either without parsing the message text.
 export {
+  AgentModeWithEnhancedLivenessException,
   BuilderValidationException,
   ConsentDeniedException,
   DuplicateScreenTypeException,
@@ -225,6 +226,11 @@ export {
   type UseSmileIDResult,
 } from "./core/models/result";
 export type { ConfigOptions } from "./core/models/config";
+export {
+  GlobalPrivacyControl,
+  GLOBAL_PRIVACY_CONTROL_WIRE_KEY,
+  globalPrivacyControlFromWire,
+} from "./core/models/global_privacy_control";
 export { LogLevel } from "./core/models/network_config";
 export type {
   CacheConfig,
@@ -374,10 +380,6 @@ export {
   UseSmileIDDocumentOverlay,
   type UseSmileIDDocumentOverlayProps,
 } from "./presentation/components/use_smile_id_document_overlay";
-export {
-  UseSmileIDFaceSilhouetteOverlay,
-  type UseSmileIDFaceSilhouetteOverlayProps,
-} from "./presentation/components/use_smile_id_face_silhouette_overlay";
 export {
   UseSmileIDInstructionsHero,
   type UseSmileIDInstructionsHeroProps,