@smileid/usesmileid 12.0.0-beta01 → 12.0.1

package/src/data/util/use_smile_id_token_decoder.ts

@@ -20,6 +20,14 @@ declare function atob(data: string): string;
  */
 export type DecodedToken = {
   readonly sdkConfig?: SdkConfig;
+  /**
+   * Canonical `partner_id` from the top-level JWT claim (server-padded form,
+   * e.g. `"002"`), which can differ from the partner-supplied config string
+   * (`"2"`). The Smile EXIF tagger keys its HMAC/AES derivation on this so the
+   * stamped value matches the partner_id the backend validates against.
+   * `undefined` when the claim is absent.
+   */
+  readonly partnerId?: string;
 };
 
 /**
@@ -40,6 +48,73 @@ export type DecodedToken = {
  * This function never throws — all failure paths return a value.
  */
 export function decodeSmileIDToken(token: string): DecodedToken | undefined {
+  const payloadObject = parseJwtPayloadObject(token);
+  if (payloadObject === undefined) return undefined;
+
+  // Canonical partner_id — a TOP-LEVEL claim (server-padded form, e.g. "002"), a sibling of
+  // `sdk_config`. The EXIF tagger keys on this so the stamped value matches the backend. Spread
+  // in only when present so `exactOptionalPropertyTypes` isn't violated by an explicit undefined.
+  const rawPartnerId = payloadObject["partner_id"];
+  const partnerIdField =
+    typeof rawPartnerId === "string" ? { partnerId: rawPartnerId } : {};
+
+  const rawClaim = payloadObject["sdk_config"];
+
+  if (rawClaim === undefined || rawClaim === null) {
+    // No claim present — defaults apply throughout the flow.
+    return { ...partnerIdField };
+  }
+
+  if (typeof rawClaim !== "object" || Array.isArray(rawClaim)) {
+    // Claim exists but is not an object — treat as absent.
+    return { ...partnerIdField };
+  }
+
+  const parseResult = sdkConfigSchema.safeParse(rawClaim);
+  if (!parseResult.success) {
+    // Zod rejected the claim shape — degrade to defaults.
+    if (!(parseResult.error instanceof ZodError)) {
+      // Unreachable in practice (safeParse always gives ZodError on
+      // failure), but degrade gracefully to preserve the never-throws
+      // contract rather than surfacing an unexpected error type.
+      return { ...partnerIdField };
+    }
+    return { ...partnerIdField };
+  }
+
+  return { sdkConfig: parseResult.data, ...partnerIdField };
+}
+
+/**
+ * Extract the server-driven security policy bit-code from the token's **top-level** `policy` claim
+ * (a sibling of `sdk_config`, not nested inside it — mirroring the backend and the v11
+ * `/v1/auth_smile` response).
+ *
+ * Internal-only: deliberately NOT re-exported from the package entrypoint (`src/index.ts`), so the
+ * policy never widens the partner-facing API. It rides here — alongside the decoder — rather than
+ * on the exported {@link DecodedToken} for the same reason. See `SecurityPolicy` and
+ * `docs/Policy.md`.
+ *
+ * Returns `undefined` when the token is unparseable or carries no numeric top-level `policy`. The
+ * caller treats `undefined` as fail-secure (every behaviour active), so this never throws.
+ */
+export function decodeSecurityPolicyBitCode(token: string): number | undefined {
+  const payloadObject = parseJwtPayloadObject(token);
+  if (payloadObject === undefined) return undefined;
+
+  const policy = payloadObject["policy"];
+  return typeof policy === "number" ? policy : undefined;
+}
+
+/**
+ * Parse the JWT payload (middle segment) into a JSON object, or `undefined` when the token is
+ * structurally invalid (not exactly three `.`-delimited segments, non-base64url payload, or a
+ * non-object JSON payload). Shared by {@link decodeSmileIDToken} and
+ * {@link decodeSecurityPolicyBitCode} so both read the payload the same way.
+ */
+function parseJwtPayloadObject(
+  token: string,
+): Record<string, unknown> | undefined {
   const segments = token.split(".");
   if (segments.length !== 3) return undefined;
 
@@ -74,34 +149,7 @@ export function decodeSmileIDToken(token: string): DecodedToken | undefined {
     return undefined;
   }
 
-  // Valid structural token from here on — failures below degrade to an
-  // empty DecodedToken (sdkConfig unset) rather than returning undefined.
-  const payloadObject = payload as Record<string, unknown>;
-  const rawClaim = payloadObject["sdk_config"];
-
-  if (rawClaim === undefined || rawClaim === null) {
-    // No claim present — defaults apply throughout the flow.
-    return {};
-  }
-
-  if (typeof rawClaim !== "object" || Array.isArray(rawClaim)) {
-    // Claim exists but is not an object — treat as absent.
-    return {};
-  }
-
-  const parseResult = sdkConfigSchema.safeParse(rawClaim);
-  if (!parseResult.success) {
-    // Zod rejected the claim shape — degrade to defaults.
-    if (!(parseResult.error instanceof ZodError)) {
-      // Unreachable in practice (safeParse always gives ZodError on
-      // failure), but degrade gracefully to preserve the never-throws
-      // contract rather than surfacing an unexpected error type.
-      return {};
-    }
-    return {};
-  }
-
-  return { sdkConfig: parseResult.data };
+  return payload as Record<string, unknown>;
 }
 
 /**

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,

package/src/l10n/strings_en.ts

@@ -160,6 +160,7 @@ export const enStrings = {
   si_ess_look_left: "Turn your head to the left",
   si_ess_look_right: "Turn your head to the right",
   si_ess_look_up: "Turn your head slightly upwards",
+  si_ess_look_at_camera: "Look at the camera",
   si_ess_capture_initial_instruction:
     "Centre your face in the frame and turn your head in the direction of the arrow.",
   si_ess_hold_still: "Hold still…",
@@ -168,4 +169,4 @@ export const enStrings = {
 export type SiKey = keyof typeof enStrings;
 
 /** Total canonical key count — pinned in tests to catch a missed addition/deletion at PR time. */
-export const CANONICAL_KEY_COUNT = 118 as const;
+export const CANONICAL_KEY_COUNT = 119 as const;

package/src/l10n/use_smile_id_localizations.ts

@@ -676,6 +676,9 @@ export class UseSmileIDLocalizations {
   get siEssLookUp(): string {
     return this._s("si_ess_look_up", enStrings.si_ess_look_up);
   }
+  get siEssLookAtCamera(): string {
+    return this._s("si_ess_look_at_camera", enStrings.si_ess_look_at_camera);
+  }
   get siEssCaptureInitialInstruction(): string {
     return this._s(
       "si_ess_capture_initial_instruction",

package/src/metadata/__tests__/device_orientation_collector.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+
+import { DeviceOrientationCollector } from "../device_orientation_collector";
+
+/**
+ * Regression guard: with no accelerometer samples, `device_movement_detected` must be absent
+ * (`null`) and `device_positions` empty — never a sentinel. Mirrored across all four SDKs.
+ */
+describe("DeviceOrientationCollector", () => {
+  it("omits movement (null) and positions when no samples were collected", () => {
+    const collector = new DeviceOrientationCollector();
+    expect(collector.deviceMovementDetected).toBeNull();
+    expect(collector.devicePositions).toHaveLength(0);
+  });
+});

package/src/metadata/__tests__/metadata_configuration_mappers.test.ts

@@ -0,0 +1,254 @@
+import {
+  AnalyzerFactoryKey,
+  faceConfigSchema,
+} from "@smileid/usesmileid_bridge";
+import { describe, expect, it } from "vitest";
+
+import { DocumentCaptureMode } from "../../core/models/document_capture_mode";
+import { CaptureType } from "../../core/models/ml_config";
+import type { FlowConfiguration } from "../../presentation/flow/config/flow_configuration";
+import { ScreensBuilder } from "../../presentation/flow/dsl/builder/screens_builder";
+import {
+  ModelProvider,
+  MODEL_DESCRIPTOR_UNKNOWN,
+} from "../model_configuration";
+import { GlobalPrivacyControl } from "../../core/models/global_privacy_control";
+import {
+  flowConfigurationToBuilderConfiguration,
+  flowConfigurationToModelConfiguration,
+  flowConfigurationToSelfieLivenessTelemetry,
+} from "../metadata_configuration_mappers";
+
+function flow(
+  buildScreens: (screens: ScreensBuilder) => void,
+  ml?: FlowConfiguration["ml"],
+): FlowConfiguration {
+  const screensBuilder = new ScreensBuilder();
+  buildScreens(screensBuilder);
+  return {
+    screens: screensBuilder.build(),
+    ...(ml ? { ml } : {}),
+    onResult: () => {},
+  };
+}
+
+describe("flowConfigurationToBuilderConfiguration", () => {
+  it("reflects the consent screen", () => {
+    const config = flowConfigurationToBuilderConfiguration(
+      flow((screens) => {
+        screens.consent((consent) => {
+          consent.partnerIcon = "icon";
+          consent.showAttribution = false;
+        });
+      }),
+    );
+    expect(config.consentScreenUsed).toBe(true);
+    expect(config.consentIconProvided).toBe(true);
+    // A React Native consent icon is a ReactNode with no measurable pixel size.
+    expect(config.consentIconDimensions).toBeNull();
+    expect(config.consentAttributionShown).toBe(false);
+  });
+
+  it("reports consent absent when there is no consent screen", () => {
+    const config = flowConfigurationToBuilderConfiguration(
+      flow((screens) => screens.instructions()),
+    );
+    expect(config.consentScreenUsed).toBe(false);
+    expect(config.consentIconProvided).toBe(false);
+  });
+
+  it("maps selfie capture flags", () => {
+    const config = flowConfigurationToBuilderConfiguration(
+      flow((screens) => {
+        screens.capture((capture) => {
+          capture.captureType = CaptureType.selfie;
+          capture.selfie((selfie) => {
+            selfie.allowAgentMode = true;
+            selfie.enableEnhancedLiveness = true;
+          });
+        });
+        screens.preview();
+      }),
+    );
+    expect(config.allowAgentMode).toBe(true);
+    expect(config.enhancedLivenessEnabled).toBe(true);
+    expect(config.selfiePreviewEnabled).toBe(true);
+    expect(config.documentPreviewEnabled).toBe(false);
+  });
+
+  it("maps document capture flags and capture mode", () => {
+    const config = flowConfigurationToBuilderConfiguration(
+      flow((screens) => {
+        screens.capture((capture) => {
+          capture.captureType = CaptureType.document;
+          capture.document((document) => {
+            document.captureMode = DocumentCaptureMode.ManualCapture;
+            document.allowGalleryUpload = true;
+            document.captureBothSides = false;
+            document.allowSkipBack = true;
+          });
+        });
+        screens.preview();
+      }),
+    );
+    expect(config.autoCaptureEnabled).toBe("manual");
+    expect(config.allowGalleryUpload).toBe(true);
+    expect(config.captureBothSides).toBe(false);
+    expect(config.allowSkipBack).toBe(true);
+    expect(config.documentPreviewEnabled).toBe(true);
+    expect(config.selfiePreviewEnabled).toBe(false);
+  });
+
+  it("maps each document capture mode to the wire enum", () => {
+    const modeFor = (captureMode: DocumentCaptureMode): string =>
+      flowConfigurationToBuilderConfiguration(
+        flow((screens) => {
+          screens.capture((capture) => {
+            capture.captureType = CaptureType.document;
+            capture.document((document) => {
+              document.captureMode = captureMode;
+            });
+          });
+        }),
+      ).autoCaptureEnabled;
+
+    expect(modeFor(DocumentCaptureMode.AutoCapture)).toBe("auto_capture_only");
+    expect(modeFor(DocumentCaptureMode.ManualCapture)).toBe("manual");
+    expect(modeFor(DocumentCaptureMode.AutoCaptureWithManualFallback())).toBe(
+      "autocapture_default",
+    );
+  });
+
+  it("reports submission skipped without a processing screen", () => {
+    const selfieOnly = (screens: ScreensBuilder) =>
+      screens.capture((capture) => {
+        capture.captureType = CaptureType.selfie;
+      });
+    expect(
+      flowConfigurationToBuilderConfiguration(flow(selfieOnly))
+        .submissionSkipped,
+    ).toBe(true);
+    expect(
+      flowConfigurationToBuilderConfiguration(
+        flow((screens) => {
+          selfieOnly(screens);
+          screens.processing();
+        }),
+      ).submissionSkipped,
+    ).toBe(false);
+  });
+});
+
+describe("flowConfigurationToModelConfiguration", () => {
+  it("maps the face backend key with the noop document fallback", () => {
+    const config = flow(
+      (screens) =>
+        screens.capture((capture) => {
+          capture.captureType = CaptureType.selfie;
+        }),
+      {
+        analyzers: {
+          selfieConfig: faceConfigSchema.parse({
+            analyzerFactoryKey: AnalyzerFactoryKey.MLKitFace,
+          }),
+        },
+      },
+    );
+    const model = flowConfigurationToModelConfiguration(config);
+    expect(model.faceModel.provider).toBe(ModelProvider.Google);
+    expect(model.faceModel.name).toBe("play-services-mlkit-face-detection");
+    expect(model.documentModel.provider).toBe(ModelProvider.Smile);
+  });
+
+  it("falls back to unknown for an ML-free flow", () => {
+    const model = flowConfigurationToModelConfiguration(
+      flow((screens) =>
+        screens.capture((capture) => {
+          capture.captureType = CaptureType.selfie;
+        }),
+      ),
+    );
+    expect(model.faceModel).toEqual(MODEL_DESCRIPTOR_UNKNOWN);
+    expect(model.documentModel.provider).toBe(ModelProvider.Smile);
+  });
+});
+
+describe("flowConfigurationToSelfieLivenessTelemetry", () => {
+  it("reports smile for a standard selfie flow", () => {
+    const telemetry = flowConfigurationToSelfieLivenessTelemetry(
+      flow((screens) =>
+        screens.capture((capture) => {
+          capture.captureType = CaptureType.selfie;
+          capture.selfie(() => {});
+        }),
+      ),
+    );
+    expect(telemetry.activeLivenessType).toBe("smile");
+    expect(telemetry.activeLivenessVersion).toBe("2.0.0");
+    expect(telemetry.selfieImageOrigin).toBe("front_camera");
+  });
+
+  it("reports head_pose when enhanced liveness is on", () => {
+    const telemetry = flowConfigurationToSelfieLivenessTelemetry(
+      flow((screens) =>
+        screens.capture((capture) => {
+          capture.captureType = CaptureType.selfie;
+          capture.selfie((selfie) => {
+            selfie.enableEnhancedLiveness = true;
+          });
+        }),
+      ),
+    );
+    expect(telemetry.activeLivenessType).toBe("head_pose");
+  });
+
+  it("reports back_camera in agent mode", () => {
+    const telemetry = flowConfigurationToSelfieLivenessTelemetry(
+      flow((screens) =>
+        screens.capture((capture) => {
+          capture.captureType = CaptureType.selfie;
+          capture.selfie((selfie) => {
+            selfie.allowAgentMode = true;
+          });
+        }),
+      ),
+    );
+    expect(telemetry.selfieImageOrigin).toBe("back_camera");
+    expect(telemetry.activeLivenessType).toBe("smile");
+  });
+
+  it("is all-null for a document-only flow", () => {
+    const telemetry = flowConfigurationToSelfieLivenessTelemetry(
+      flow((screens) =>
+        screens.capture((capture) => {
+          capture.captureType = CaptureType.document;
+        }),
+      ),
+    );
+    expect(telemetry.activeLivenessType).toBeNull();
+    expect(telemetry.selfieImageOrigin).toBeNull();
+  });
+
+  it("global privacy control lands in the configuration metadata", () => {
+    // Default posture: a snapshot without a config block reports the
+    // opt-out baseline.
+    expect(
+      flowConfigurationToBuilderConfiguration(flow(() => {}))
+        .globalPrivacyControl,
+    ).toBe("opt-out");
+
+    // Explicit legacy posture flows through the config snapshot.
+    const optIn: FlowConfiguration = {
+      ...flow(() => {}),
+      config: {
+        enableCrashReporting: true,
+        enableDebugMode: false,
+        allowOfflineMode: false,
+        globalPrivacyControl: GlobalPrivacyControl.OptIn,
+      },
+    };
+    expect(
+      flowConfigurationToBuilderConfiguration(optIn).globalPrivacyControl,
+    ).toBe("opt-in");
+  });
+});

package/src/metadata/__tests__/metadata_configuration_objects.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  type BuilderConfiguration,
+  builderConfigurationToJson,
+} from "../builder_configuration";
+import {
+  type ModelConfiguration,
+  ModelProvider,
+  modelConfigurationToJson,
+} from "../model_configuration";
+
+const builderConfiguration: BuilderConfiguration = {
+  consentScreenUsed: true,
+  consentIconProvided: true,
+  consentIconDimensions: { width: 120, height: 80 },
+  consentAttributionShown: true,
+  instructionsScreenUsed: true,
+  selfiePreviewEnabled: true,
+  documentPreviewEnabled: false,
+  submissionSkipped: false,
+  allowAgentMode: true,
+  enhancedLivenessEnabled: false,
+  autoCaptureEnabled: "autocapture_default",
+  allowGalleryUpload: true,
+  captureBothSides: true,
+  allowSkipBack: false,
+  globalPrivacyControl: "opt-out",
+};
+
+const modelConfiguration: ModelConfiguration = {
+  faceModel: {
+    provider: ModelProvider.Google,
+    name: "play-services-mlkit-face-detection",
+    version: "17.1.0",
+    bundled: false,
+  },
+  documentModel: {
+    provider: ModelProvider.Smile,
+    name: "noop_document_detector",
+    version: "12.0.1",
+    bundled: true,
+  },
+};
+
+describe("builder_configuration_object", () => {
+  it("serialises the full schema with snake_case keys", () => {
+    const json = builderConfigurationToJson(builderConfiguration);
+    expect(json.consent_screen_used).toBe(true);
+    expect(json.consent_icon_provided).toBe(true);
+    expect(json.consent_icon_dimensions).toEqual({ width: 120, height: 80 });
+    expect(json.auto_capture_enabled).toBe("autocapture_default");
+    expect(json.allow_gallery_upload).toBe(true);
+  });
+
+  it("emits consent_icon_dimensions as null when absent", () => {
+    const json = builderConfigurationToJson({
+      ...builderConfiguration,
+      consentIconProvided: false,
+      consentIconDimensions: null,
+    });
+    expect(json.consent_icon_dimensions).toBeNull();
+    // round-trips through JSON.stringify as an explicit null, not an omitted key
+    const reparsed = JSON.parse(JSON.stringify(json)) as Record<
+      string,
+      unknown
+    >;
+    expect("consent_icon_dimensions" in reparsed).toBe(true);
+    expect(reparsed.consent_icon_dimensions).toBeNull();
+  });
+});
+
+describe("model_configuration_object", () => {
+  it("serialises both model descriptors", () => {
+    const json = modelConfigurationToJson(modelConfiguration);
+    const face = json.face_model as Record<string, unknown>;
+    expect(face.provider).toBe("google");
+    expect(face.name).toBe("play-services-mlkit-face-detection");
+    expect(face.version).toBe("17.1.0");
+    expect(face.bundled).toBe(false);
+
+    const document = json.document_model as Record<string, unknown>;
+    expect(document.provider).toBe("smile");
+    expect(document.bundled).toBe(true);
+  });
+});

package/src/metadata/__tests__/metadata_device_context.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  UseSmileIDMetadata,
+  type UseSmileIDMetadataFields,
+} from "../use_smile_id_metadata";
+
+function fields(
+  overrides: Partial<UseSmileIDMetadataFields> = {},
+): UseSmileIDMetadataFields {
+  return {
+    sdkVersion: "12.0.1",
+    sdk: "react-native-expo",
+    deviceOs: "Android 14",
+    deviceModel: "",
+    appName: "TestApp",
+    sessionId: "session",
+    clientIp: "",
+    networkConnection: "",
+    carrierInfo: "",
+    proxy: false,
+    timezone: "",
+    locale: "",
+    screenResolution: "",
+    memoryInfoMb: 0,
+    deviceOrientation: "",
+    systemArchitecture: "",
+    numberOfCameras: 0,
+    hostApplication: "",
+    proximitySensor: false,
+    securityPolicyVersion: "",
+    sdkConfigSource: "default",
+    imageWidth: 0,
+    imageHeight: 0,
+    livenessImageWidth: 0,
+    livenessImageHeight: 0,
+    ...overrides,
+  };
+}
+
+function value(name: string, fieldsValue: UseSmileIDMetadataFields) {
+  return new UseSmileIDMetadata(fieldsValue)
+    .toEntries()
+    .find((entry) => entry.name === name)?.value;
+}
+
+describe("device-context keys (62-key parity)", () => {
+  it("omits the new keys at their defaults", () => {
+    const names = new UseSmileIDMetadata(fields())
+      .toEntries()
+      .map((entry) => entry.name);
+    for (const key of [
+      "build_brand",
+      "build_device",
+      "build_fingerprint",
+      "build_product",
+      "local_time_of_enrolment",
+      "battery_status",
+    ]) {
+      expect(names).not.toContain(key);
+    }
+  });
+
+  it("emits build + carrier + local time when present", () => {
+    const populated = fields({
+      buildBrand: "google",
+      buildDevice: "husky",
+      buildFingerprint: "google/husky:14",
+      buildProduct: "husky",
+      carrierInfo: "MTN",
+      localTimeOfEnrolment: "2026-06-24T10:00:00.000+03:00",
+    });
+    expect(value("build_brand", populated)).toBe("google");
+    expect(value("build_device", populated)).toBe("husky");
+    expect(value("build_fingerprint", populated)).toBe("google/husky:14");
+    expect(value("build_product", populated)).toBe("husky");
+    expect(value("carrier_info", populated)).toBe("MTN");
+    expect(value("local_time_of_enrolment", populated)).toBe(
+      "2026-06-24T10:00:00.000+03:00",
+    );
+  });
+
+  it("emits battery_status including the meaningful on-battery value", () => {
+    expect(value("battery_status", fields({ batteryStatus: 0 }))).toBe("0");
+    expect(value("battery_status", fields({ batteryStatus: 1 }))).toBe("1");
+    expect(value("battery_status", fields({ batteryStatus: -1 }))).toBe("-1");
+  });
+
+  it("emits wrapper identity when present and omits it when blank", () => {
+    const populated = fields({
+      wrapperName: "react_native_expo",
+      wrapperVersion: "12.0.1",
+    });
+    expect(value("wrapper_name", populated)).toBe("react_native_expo");
+    expect(value("wrapper_version", populated)).toBe("12.0.1");
+
+    const names = new UseSmileIDMetadata(fields())
+      .toEntries()
+      .map((entry) => entry.name);
+    expect(names).not.toContain("wrapper_name");
+  });
+
+  it("emits sdk_launch_count when positive and omits it when zero/undefined", () => {
+    expect(value("sdk_launch_count", fields({ sdkLaunchCount: 9 }))).toBe("9");
+    const zero = new UseSmileIDMetadata(fields({ sdkLaunchCount: 0 }))
+      .toEntries()
+      .map((entry) => entry.name);
+    expect(zero).not.toContain("sdk_launch_count");
+    const absent = new UseSmileIDMetadata(fields())
+      .toEntries()
+      .map((entry) => entry.name);
+    expect(absent).not.toContain("sdk_launch_count");
+  });
+
+  it("emits privileges verbatim and omits it when absent", () => {
+    const raw = '{"1":"100010","8":"100100"}';
+    expect(value("privileges", fields({ privileges: raw }))).toBe(raw);
+    const absent = new UseSmileIDMetadata(fields())
+      .toEntries()
+      .map((entry) => entry.name);
+    expect(absent).not.toContain("privileges");
+  });
+
+  it("emits geolocation as a JSON-object string and omits it when absent", () => {
+    const raw = value(
+      "geolocation",
+      fields({
+        geolocation: {
+          latitude: 1.5,
+          longitude: -2.5,
+          accuracy: "precise",
+          source: "gps",
+        },
+      }),
+    );
+    expect(JSON.parse(raw!)).toEqual({
+      latitude: 1.5,
+      longitude: -2.5,
+      accuracy: "precise",
+      source: "gps",
+    });
+    const absent = new UseSmileIDMetadata(fields())
+      .toEntries()
+      .map((entry) => entry.name);
+    expect(absent).not.toContain("geolocation");
+  });
+});