@smileid/usesmileid 12.0.0-beta01 → 12.0.1

package/src/metadata/use_smile_id_metadata.ts

@@ -5,11 +5,14 @@
  * server and partner dashboards parse it positionally; `toEntries()` produces it.
  *
  * Omission rules: always-present (`sdk_version`, `sdk`, `device_os`,
- * `device_model`, `app_name`, `session_id`, `proxy`, `proximity_sensor`,
- * `security_policy_version`); conditional strings dropped when empty; conditional
- * integers dropped when zero; booleans always included, stringified.
+ * `device_model`, `app_name`, `session_id`, `security_policy_version`);
+ * conditional strings dropped when empty; conditional integers dropped when
+ * zero; `proxy` / `proximity_sensor` emitted only when actually measured
+ * (undefined = unknown, dropped) — a measured `false` is kept.
  */
 
+import type { Geolocation } from "./geolocation";
+
 export type MetadataEntry = {
   readonly name: string;
   readonly value: string;
@@ -25,7 +28,8 @@ export type UseSmileIDMetadataFields = {
   readonly clientIp: string;
   readonly networkConnection: string;
   readonly carrierInfo: string;
-  readonly proxy: boolean;
+  /** Proxy detection result → `proxy`. Undefined when never measured (omitted); a measured `false` is emitted. */
+  readonly proxy?: boolean;
   readonly timezone: string;
   readonly locale: string;
   readonly screenResolution: string;
@@ -34,7 +38,8 @@ export type UseSmileIDMetadataFields = {
   readonly systemArchitecture: string;
   readonly numberOfCameras: number;
   readonly hostApplication: string;
-  readonly proximitySensor: boolean;
+  /** Proximity-sensor availability → `proximity_sensor`. Undefined when never measured (omitted); a measured `false` is emitted. */
+  readonly proximitySensor?: boolean;
   readonly securityPolicyVersion: string;
   /** Android Keystore security level (`KeyInfo.getSecurityLevel()`, `-2`…`2`) → `supports_hardware_attestation`. Undefined on iOS and before warm-up resolves. */
   readonly hardwareAttestationSecurityLevel?: number;
@@ -44,10 +49,44 @@ export type UseSmileIDMetadataFields = {
   readonly supportsAppAttest?: boolean;
   /** Capture-param provenance → `sdk_config_source`: `"sdk_config"` when a valid JWT claim was decoded, else `"default"`. */
   readonly sdkConfigSource: string;
-  /** Resolved selfie width (px) → `image_width`: `sdk_config.selfie.width` override (when width+height > 0) or SDK default (480). Omitted when zero. */
+  /** Resolved selfie capture target dimensions → `selfie_image_dimensions` `"WxH"`: `sdk_config.selfie` override or SDK default (480x640). Dropped when a side is 0. */
   readonly imageWidth: number;
-  /** Resolved selfie height (px) → `image_height`: `sdk_config.selfie.height` override (when width+height > 0) or SDK default (640). Omitted when zero. */
   readonly imageHeight: number;
+  /** Resolved liveness capture target dimensions → `liveness_image_dimensions` `"WxH"`. Dropped when a side is 0. */
+  readonly livenessImageWidth: number;
+  readonly livenessImageHeight: number;
+  /** Device UTC offset in minutes (may be negative or 0) → `timezone_offset`. Undefined omits. */
+  readonly timezoneOffsetMinutes?: number;
+  /** `android.os.Build.*` device-context strings; empty on iOS except `buildDevice` (iOS hardware id). Omitted when empty. */
+  readonly buildBrand?: string;
+  readonly buildDevice?: string;
+  readonly buildFingerprint?: string;
+  readonly buildProduct?: string;
+  /** `Build.HARDWARE` (Android) → `build_hardware`; empty on iOS. Omitted when empty. */
+  readonly buildHardware?: string;
+  /** Install source / store (Android `PackageManager` install source) → `build_source`. Omitted when empty. */
+  readonly buildSource?: string;
+  /** Host app package id (Android) / bundle id (iOS), computed natively → `package_name`. Omitted when empty. */
+  readonly packageName?: string;
+  /** Stable per-device fingerprint (Android `ANDROID_ID` / iOS `identifierForVendor`) → `fingerprint`. Omitted when empty. */
+  readonly fingerprint?: string;
+  /** Whether an active VPN is present → `vpn`. Omitted when undefined. */
+  readonly vpn?: boolean;
+  /** App-signing certificate SHA-256 digests (Android only) → `certificate_digest` (JSON-array string). Omitted when empty. */
+  readonly certificateDigest?: readonly string[];
+  /** ISO-8601 local timestamp captured at request build time → `local_time_of_enrolment`. */
+  readonly localTimeOfEnrolment?: string;
+  /** Charging plug status → `battery_status` (`-1` unknown, `0` on-battery, `1` plugged in). Omitted when undefined. */
+  readonly batteryStatus?: number;
+  /** Wrapper SDK identity → `wrapper_name` / `wrapper_version` (`react_native_expo` + SDK version). Omitted when empty. */
+  readonly wrapperName?: string;
+  readonly wrapperVersion?: string;
+  /** Persisted SDK launch count → `sdk_launch_count`. Omitted when undefined or zero. */
+  readonly sdkLaunchCount?: number;
+  /** Last-known location → `geolocation` (JSON-object string). Omitted when undefined. */
+  readonly geolocation?: Geolocation;
+  /** Obfuscated device security-state signal (computed natively) → `privileges`. Omitted when undefined/blank. */
+  readonly privileges?: string;
 };
 
 export class UseSmileIDMetadata {
@@ -88,7 +127,7 @@ export class UseSmileIDMetadata {
     const fields = this._fields;
     const entries: MetadataEntry[] = [];
 
-    // Always-present: SDK constants, booleans, sessionId (UUID), and
+    // Always-present: SDK constants, sessionId (UUID), and
     // device_os/device_model/app_name (emitted even when empty). The rest
     // below use the drop-when-empty rule.
     entries.push({ name: "sdk_version", value: fields.sdkVersion });
@@ -98,12 +137,16 @@ export class UseSmileIDMetadata {
     entries.push({ name: "app_name", value: fields.appName });
     entries.push({ name: "session_id", value: fields.sessionId });
 
-    // Always-present booleans (stringified, never empty by construction)
-    entries.push({ name: "proxy", value: String(fields.proxy) });
-    entries.push({
-      name: "proximity_sensor",
-      value: String(fields.proximitySensor),
-    });
+    // Measured booleans — omitted when never measured; a measured false is kept.
+    if (fields.proxy !== undefined) {
+      entries.push({ name: "proxy", value: String(fields.proxy) });
+    }
+    if (fields.proximitySensor !== undefined) {
+      entries.push({
+        name: "proximity_sensor",
+        value: String(fields.proximitySensor),
+      });
+    }
 
     // Conditional strings — omitted when empty
     pushIfNonEmpty(entries, "client_ip", fields.clientIp);
@@ -150,9 +193,89 @@ export class UseSmileIDMetadata {
 
     // sdk_config provenance — always-present string, never empty.
     entries.push({ name: "sdk_config_source", value: fields.sdkConfigSource });
-    // Resolved selfie dimensions — omitted when zero.
-    pushIfNonZero(entries, "image_width", fields.imageWidth);
-    pushIfNonZero(entries, "image_height", fields.imageHeight);
+    // Resolved selfie / liveness capture target dimensions as "WxH"; each dropped when a side is 0.
+    if (fields.imageWidth > 0 && fields.imageHeight > 0) {
+      entries.push({
+        name: "selfie_image_dimensions",
+        value: `${fields.imageWidth}x${fields.imageHeight}`,
+      });
+    }
+    if (fields.livenessImageWidth > 0 && fields.livenessImageHeight > 0) {
+      entries.push({
+        name: "liveness_image_dimensions",
+        value: `${fields.livenessImageWidth}x${fields.livenessImageHeight}`,
+      });
+    }
+    // UTC offset in minutes (may be negative or 0); emitted whenever resolved.
+    if (fields.timezoneOffsetMinutes !== undefined) {
+      entries.push({
+        name: "timezone_offset",
+        value: String(fields.timezoneOffsetMinutes),
+      });
+    }
+
+    // Build / device-context strings — omitted when empty.
+    pushIfNonEmpty(entries, "build_brand", fields.buildBrand ?? "");
+    pushIfNonEmpty(entries, "build_device", fields.buildDevice ?? "");
+    pushIfNonEmpty(entries, "build_fingerprint", fields.buildFingerprint ?? "");
+    pushIfNonEmpty(entries, "build_product", fields.buildProduct ?? "");
+    pushIfNonEmpty(entries, "build_hardware", fields.buildHardware ?? "");
+    pushIfNonEmpty(entries, "build_source", fields.buildSource ?? "");
+    pushIfNonEmpty(entries, "package_name", fields.packageName ?? "");
+    pushIfNonEmpty(entries, "fingerprint", fields.fingerprint ?? "");
+    pushIfNonEmpty(
+      entries,
+      "local_time_of_enrolment",
+      fields.localTimeOfEnrolment ?? "",
+    );
+    // Charging status — omitted until resolved. `0` (on battery) is meaningful.
+    if (fields.batteryStatus !== undefined) {
+      entries.push({
+        name: "battery_status",
+        value: String(fields.batteryStatus),
+      });
+    }
+
+    // VPN presence — omitted until resolved; `false` is meaningful.
+    if (fields.vpn !== undefined) {
+      entries.push({ name: "vpn", value: String(fields.vpn) });
+    }
+
+    // App-signing certificate digests (Android) — JSON-array string, omitted when empty.
+    if (
+      fields.certificateDigest !== undefined &&
+      fields.certificateDigest.length > 0
+    ) {
+      entries.push({
+        name: "certificate_digest",
+        value: JSON.stringify(fields.certificateDigest),
+      });
+    }
+
+    // Wrapper SDK identity — omitted when empty.
+    pushIfNonEmpty(entries, "wrapper_name", fields.wrapperName ?? "");
+    pushIfNonEmpty(entries, "wrapper_version", fields.wrapperVersion ?? "");
+
+    // Persisted launch count — omitted until resolved or when zero.
+    if (fields.sdkLaunchCount !== undefined && fields.sdkLaunchCount > 0) {
+      entries.push({
+        name: "sdk_launch_count",
+        value: String(fields.sdkLaunchCount),
+      });
+    }
+
+    // Last-known location — JSON-object string, omitted when unresolved.
+    if (fields.geolocation !== undefined) {
+      entries.push({
+        name: "geolocation",
+        value: JSON.stringify(fields.geolocation),
+      });
+    }
+
+    // Obfuscated device privileges signal — emitted verbatim, omitted when blank.
+    if (fields.privileges !== undefined && fields.privileges.length > 0) {
+      entries.push({ name: "privileges", value: fields.privileges });
+    }
 
     // Flow-state entries appended after the device-metadata fields.
     entries.push(...this._extraEntries);

package/src/metadata/use_smile_id_metadata_factory.ts

@@ -1,13 +1,23 @@
 import { Dimensions, Platform } from "react-native";
 import {
   Attestation,
+  type DeviceIntegritySignals,
+  DeviceIntegrityProvider,
   type HardwareAttestation,
+  PrivilegesProvider,
 } from "@smileid/usesmileid_bridge";
 import {
   UseSmileIDMetadata,
   type UseSmileIDMetadataFields,
 } from "./use_smile_id_metadata";
-import { loadExpoDevice, loadExpoNetwork } from "./optional_native_modules";
+import {
+  loadAsyncStorage,
+  loadExpoBattery,
+  loadExpoCellular,
+  loadExpoDevice,
+  loadExpoNetwork,
+} from "./optional_native_modules";
+import { type Geolocation, resolveGeolocation } from "./geolocation";
 import type { SdkConfig } from "../data/model/sdk_config";
 import { resolveDimensions } from "../data/model/sdk_config_capture";
 import { SdkConfigSource } from "../data/model/sdk_config_source";
@@ -41,19 +51,22 @@ import { CameraDefaults } from "../camera/camera_defaults";
  *     before the first submission so the race is benign in practice.
  *   - Partner-supplied via [MetadataFactoryOptions]: `app_name`,
  *     `host_application`.
- *   - Empty / zero by default until a richer native bridge lands:
- *     `carrier_info`, `number_of_cameras`, `proximity_sensor`,
- *     `proxy`. Partners who want these pass a custom
+ *   - Not measurable until a richer native bridge lands:
+ *     `carrier_info` and `number_of_cameras` stay empty / zero (dropped
+ *     from the wire), and `proximity_sensor` / `proxy` stay undefined
+ *     (dropped from the wire) rather than reporting an inaccurate
+ *     `false`. Partners who want these pass a custom
  *     `MetadataProvider` to the repository.
  */
 
 // Beta release version reported to the backend as `sdk_version`. Keep in sync
 // with the `version` field across the published package.json files.
-const SDK_VERSION = "12.0.0-beta01";
+const SDK_VERSION = "12.0.1";
 // The security-policy axis is versioned independently of the SDK release tag,
 // so it stays at the base `12.0.0` (not the prerelease tag).
 const SECURITY_POLICY_VERSION = "12.0.0";
 const SDK_IDENTIFIER = "react-native-expo";
+const LAUNCH_COUNT_KEY = "com.usesmileid.metadata.sdk_launch_count";
 
 export interface MetadataProvider {
   /**
@@ -102,6 +115,30 @@ export class UseSmileIDMetadataFactory implements MetadataProvider {
   private readonly _hostApplication: string;
   private readonly _systemArchitecture: string;
   private readonly _memoryInfoMb: number;
+  // Build / device-context strings + carrier, resolved once at construction
+  // from expo-device / expo-cellular sync constants. Empty when the module is
+  // absent or the platform has no analog.
+  private readonly _buildBrand: string;
+  private readonly _buildDevice: string;
+  private readonly _buildFingerprint: string;
+  private readonly _buildProduct: string;
+  private readonly _carrierInfo: string;
+  // Resolved by the async warmup (expo-battery). Undefined until it settles —
+  // make() omits battery_status until then.
+  private _batteryStatus?: number;
+  // Persisted launch counter, resolved by the async warmup (async-storage).
+  // Undefined until it settles — make() omits sdk_launch_count until then.
+  private _sdkLaunchCount?: number;
+  // Last-known location, resolved by the async warmup (expo-location), only when a
+  // permission is already granted. Undefined until it settles / when denied.
+  private _geolocation?: Geolocation;
+  // Obfuscated device privileges JSON, resolved by the async warmup (native bridge).
+  // Undefined until it settles — make() omits the privileges field until then.
+  private _privileges?: string;
+  // Native device-integrity signals (fingerprint, package name, vpn, build hardware,
+  // install source, cert digests), resolved by the async warmup (native bridge).
+  // Undefined until it settles — make() omits the corresponding fields until then.
+  private _deviceIntegrity?: DeviceIntegritySignals;
   // Mutated by [warmup] once the async expo-network calls settle.
   // Mutable on purpose — the constructor cannot block on the
   // async API, and reading stale `""` is preferable to forcing the
@@ -142,12 +179,26 @@ export class UseSmileIDMetadataFactory implements MetadataProvider {
         typeof device.totalMemory === "number" && device.totalMemory > 0
           ? Math.round(device.totalMemory / (1024 * 1024))
           : 0;
+      this._buildBrand = device.brand?.trim() ?? "";
+      // Android `Build.DEVICE` vs iOS hardware identifier (e.g. iPhone16,2).
+      this._buildDevice =
+        (Platform.OS === "ios" ? device.modelId : device.designName)?.trim() ??
+        "";
+      this._buildFingerprint = device.osBuildFingerprint?.trim() ?? "";
+      this._buildProduct = device.productName?.trim() ?? "";
     } else {
       this._deviceModel = "";
       this._systemArchitecture = "";
       this._memoryInfoMb = 0;
+      this._buildBrand = "";
+      this._buildDevice = "";
+      this._buildFingerprint = "";
+      this._buildProduct = "";
     }
 
+    // Carrier name from expo-cellular's sync constant (empty when absent).
+    this._carrierInfo = loadExpoCellular()?.carrier?.trim() ?? "";
+
     // Fire-and-forget warmup of the async network fields. The
     // promise is intentionally unawaited — capture flows take
     // several seconds before the first `make()`, by which time
@@ -206,7 +257,86 @@ export class UseSmileIDMetadataFactory implements MetadataProvider {
             /* leave the cached empty string */
           })
       : Promise.resolve();
-    await Promise.all([stateResult, ipResult]);
+    await Promise.all([
+      stateResult,
+      ipResult,
+      this._warmUpBatteryStatus(),
+      this._warmUpLaunchCount(),
+      this._warmUpGeolocation(),
+      this._warmUpPrivileges(),
+      this._warmUpDeviceIntegrity(),
+    ]);
+  }
+
+  /**
+   * Resolve the last-known location (expo-location) into the cache — only when a permission
+   * is already granted (never prompts). Fail-open: leaves `_geolocation` unset otherwise.
+   */
+  private async _warmUpGeolocation(): Promise<void> {
+    const geolocation = await resolveGeolocation();
+    if (geolocation) this._geolocation = geolocation;
+  }
+
+  /**
+   * Resolve the obfuscated device privileges signal from the native bridge into the cache.
+   * Fail-open: `PrivilegesProvider` returns `"{}"` when the native module is unavailable.
+   */
+  private async _warmUpPrivileges(): Promise<void> {
+    const privileges = await PrivilegesProvider.privileges();
+    if (privileges.length > 0) this._privileges = privileges;
+  }
+
+  /**
+   * Resolve the native device-integrity signals (fingerprint, package name, vpn, build
+   * hardware, install source, cert digests) from the bridge into the cache. Fail-open:
+   * `DeviceIntegrityProvider` returns empty/undefined values when the native module is absent.
+   */
+  private async _warmUpDeviceIntegrity(): Promise<void> {
+    this._deviceIntegrity = await DeviceIntegrityProvider.signals();
+  }
+
+  /**
+   * Read, increment, and persist the SDK launch counter via async-storage.
+   * Fail-open: leaves `_sdkLaunchCount` unset when the package is absent.
+   */
+  private async _warmUpLaunchCount(): Promise<void> {
+    const store = loadAsyncStorage();
+    if (!store) return;
+    try {
+      const current = Number(await store.getItem(LAUNCH_COUNT_KEY)) || 0;
+      const next = current + 1;
+      await store.setItem(LAUNCH_COUNT_KEY, String(next));
+      this._sdkLaunchCount = next;
+    } catch {
+      /* leave _sdkLaunchCount unset */
+    }
+  }
+
+  /**
+   * Resolve the charging state (expo-battery) into the cache, mapped to the
+   * cross-platform plug status: `-1` unknown, `0` on battery, `1` plugged in.
+   * Fail-open: leaves `_batteryStatus` unset when the module is absent.
+   */
+  private async _warmUpBatteryStatus(): Promise<void> {
+    const battery = loadExpoBattery();
+    if (!battery) return;
+    try {
+      // expo-battery BatteryState: 0 unknown, 1 unplugged, 2 charging, 3 full.
+      const state = await battery.getBatteryStateAsync();
+      switch (state) {
+        case 1:
+          this._batteryStatus = 0;
+          break;
+        case 2:
+        case 3:
+          this._batteryStatus = 1;
+          break;
+        default:
+          this._batteryStatus = -1;
+      }
+    } catch {
+      /* leave _batteryStatus unset */
+    }
   }
 
   /**
@@ -261,6 +391,13 @@ export class UseSmileIDMetadataFactory implements MetadataProvider {
       selfieDims?.width ?? CameraDefaults.selfieJpegTargetWidth;
     const imageHeight =
       selfieDims?.height ?? CameraDefaults.selfieJpegTargetHeight;
+    // Liveness frames use the same capture target as the selfie (480x640); the sdk_config
+    // liveness group overrides it when present.
+    const livenessDims = resolveDimensions(sdkConfig?.liveness);
+    const livenessImageWidth =
+      livenessDims?.width ?? CameraDefaults.selfieJpegTargetWidth;
+    const livenessImageHeight =
+      livenessDims?.height ?? CameraDefaults.selfieJpegTargetHeight;
 
     const fields: UseSmileIDMetadataFields = {
       sdkVersion: SDK_VERSION,
@@ -271,13 +408,14 @@ export class UseSmileIDMetadataFactory implements MetadataProvider {
       sessionId: this._sessionId,
       clientIp: this._clientIp,
       networkConnection: this._networkConnection,
-      // No expo API exposes carrier info; leave empty until a
-      // dedicated native module lands.
-      carrierInfo: "",
-      proxy: false,
+      carrierInfo: this._carrierInfo,
+      // proxy / proximitySensor are not measurable without a native bridge;
+      // leaving them undefined keeps the keys off the wire rather than
+      // reporting an inaccurate false.
       // Dynamic — re-resolved per submission so mid-flow changes
       // (rotation, locale switch) are captured.
       timezone: resolveTimezone(),
+      timezoneOffsetMinutes: resolveTimezoneOffsetMinutes(),
       locale: resolveLocale(),
       screenResolution: resolveScreenResolution(),
       memoryInfoMb: this._memoryInfoMb,
@@ -285,13 +423,43 @@ export class UseSmileIDMetadataFactory implements MetadataProvider {
       systemArchitecture: this._systemArchitecture,
       numberOfCameras: 0,
       hostApplication: this._hostApplication,
-      proximitySensor: false,
       securityPolicyVersion: SECURITY_POLICY_VERSION,
       ...androidAttestation,
       ...iosAttestation,
       sdkConfigSource,
       imageWidth,
       imageHeight,
+      livenessImageWidth,
+      livenessImageHeight,
+      buildBrand: this._buildBrand,
+      buildDevice: this._buildDevice,
+      buildFingerprint: this._buildFingerprint,
+      buildProduct: this._buildProduct,
+      buildHardware: this._deviceIntegrity?.buildHardware ?? "",
+      buildSource: this._deviceIntegrity?.buildSource ?? "",
+      packageName: this._deviceIntegrity?.packageName ?? "",
+      fingerprint: this._deviceIntegrity?.fingerprint ?? "",
+      localTimeOfEnrolment: resolveLocalTimeOfEnrolment(),
+      wrapperName: "react_native_expo",
+      wrapperVersion: SDK_VERSION,
+      ...(this._deviceIntegrity?.vpn !== undefined
+        ? { vpn: this._deviceIntegrity.vpn }
+        : {}),
+      ...(this._deviceIntegrity?.certificateDigest !== undefined
+        ? { certificateDigest: this._deviceIntegrity.certificateDigest }
+        : {}),
+      ...(this._batteryStatus !== undefined
+        ? { batteryStatus: this._batteryStatus }
+        : {}),
+      ...(this._sdkLaunchCount !== undefined
+        ? { sdkLaunchCount: this._sdkLaunchCount }
+        : {}),
+      ...(this._geolocation !== undefined
+        ? { geolocation: this._geolocation }
+        : {}),
+      ...(this._privileges !== undefined
+        ? { privileges: this._privileges }
+        : {}),
     };
     return new UseSmileIDMetadata(fields);
   }
@@ -300,20 +468,39 @@ export class UseSmileIDMetadataFactory implements MetadataProvider {
 // --- field resolvers --------------------------------------------------------
 
 function resolveDeviceOs(): string {
-  // Human-readable string with platform name + version. Examples:
-  //   "iOS 17.4"
-  //   "Android 14"
+  // `"iOS 17.4"` / `"Android 12"` — the shape the native EXIF tagger stamps.
   const platform =
     Platform.OS === "ios"
       ? "iOS"
       : Platform.OS === "android"
         ? "Android"
         : Platform.OS;
-  const version =
-    typeof Platform.Version !== "undefined" ? String(Platform.Version) : "";
+  const version = resolveOsVersion();
   return version ? `${platform} ${version}` : platform;
 }
 
+function resolveOsVersion(): string {
+  if (Platform.OS === "android") {
+    const release = (
+      Platform.constants as { Release?: string | number } | undefined
+    )?.Release;
+    if (release !== undefined && release !== null && `${release}` !== "") {
+      return `${release}`;
+    }
+  }
+  return typeof Platform.Version !== "undefined"
+    ? String(Platform.Version)
+    : "";
+}
+
+function resolveLocalTimeOfEnrolment(): string {
+  try {
+    return new Date().toISOString();
+  } catch {
+    return "";
+  }
+}
+
 function resolveTimezone(): string {
   try {
     return Intl.DateTimeFormat().resolvedOptions().timeZone ?? "";
@@ -322,6 +509,14 @@ function resolveTimezone(): string {
   }
 }
 
+/**
+ * Current device offset from UTC in minutes (negative west of UTC). `Date.getTimezoneOffset`
+ * returns minutes *behind* UTC (positive west), so negate it to report the UTC offset.
+ */
+function resolveTimezoneOffsetMinutes(): number {
+  return -new Date().getTimezoneOffset();
+}
+
 function resolveLocale(): string {
   try {
     return Intl.DateTimeFormat().resolvedOptions().locale ?? "";