@scalebun/react-native 1.10.5 → 1.10.7

package/dist/scalebun.full.js

@@ -89,9 +89,9 @@ var init_internalLogger = __esm({
       }
       /** Set level from the public string name used in config (e.g. 'warn'). */
       setLevelByName(name) {
-        const resolved = LEVEL_BY_NAME[name];
-        if (resolved !== void 0) {
-          this.level = resolved;
+        const resolved3 = LEVEL_BY_NAME[name];
+        if (resolved3 !== void 0) {
+          this.level = resolved3;
         }
       }
       /** Current numeric level — exposed for callers that branch on dev verbosity. */
@@ -605,7 +605,7 @@ var SDK_VERSION;
 var init_version = __esm({
   "lib/module/core/constants/version.js"() {
     "use strict";
-    SDK_VERSION = "1.10.5";
+    SDK_VERSION = "1.10.7";
   }
 });
 
@@ -647,6 +647,15 @@ function staticDeviceContext() {
   if (c.Model) out.device_model = String(c.Model);
   if (c.Manufacturer) out.manufacturer = String(c.Manufacturer);
   else if (c.Brand) out.manufacturer = String(c.Brand);
+  else if (out.platform_os === "ios") out.manufacturer = "Apple";
+  return out;
+}
+function nativeDeviceContext(info) {
+  const out = {};
+  if (!info) return out;
+  if (info.osVersion) out.os_version = info.osVersion;
+  if (info.deviceModel) out.device_model = info.deviceModel;
+  if (info.manufacturer) out.manufacturer = info.manufacturer;
   return out;
 }
 function mergeDeviceContext(configured, detected = staticDeviceContext()) {
@@ -11232,6 +11241,27 @@ var init_EventTracker = __esm({
         }
         this.persistQueue();
       }
+      /**
+       * Fold in device facts that were not knowable at init.
+       *
+       * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+       * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+       * async and may not be installed at all. Without this the iOS half of every install reported no
+       * model whatsoever.
+       *
+       * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+       * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+       * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+       * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+       * cannot blank a value the static path already found.
+       */
+      applyDetectedContext(patch) {
+        if (!patch || Object.keys(patch).length === 0) return;
+        this.cfg.context = {
+          ...this.cfg.context ?? {},
+          ...patch
+        };
+      }
       // ─── internals ─────────────────────────────────────────────────────────────
       buildEnvelope(eventName, properties) {
         const ctx = this.cfg.context ?? {};
@@ -11581,10 +11611,249 @@ var init_deviceAttributes = __esm({
   }
 });
 
+// lib/module/features/ota/crypto/loadEd25519.js
+function loadEd25519() {
+  try {
+    const mod = require("@noble/ed25519");
+    const ed = mod?.default ?? mod;
+    if (typeof ed?.verifyAsync === "function" || typeof ed?.verify === "function") {
+      return ed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var init_loadEd25519 = __esm({
+  "lib/module/features/ota/crypto/loadEd25519.js"() {
+    "use strict";
+  }
+});
+
+// lib/module/features/ota/crypto/loadSha512.js
+function loadSha512() {
+  try {
+    const mod = require("@noble/hashes/sha2.js");
+    const sha512 = mod?.sha512 ?? mod?.default?.sha512;
+    return typeof sha512 === "function" ? sha512 : null;
+  } catch {
+    return null;
+  }
+}
+var init_loadSha512 = __esm({
+  "lib/module/features/ota/crypto/loadSha512.js"() {
+    "use strict";
+  }
+});
+
+// lib/module/features/ota/crypto/builtinVerifier.js
+var builtinVerifier_exports = {};
+__export(builtinVerifier_exports, {
+  _resetBuiltinVerifier: () => _resetBuiltinVerifier,
+  decodeSignature: () => decodeSignature,
+  getBuiltinVerifier: () => getBuiltinVerifier
+});
+function hexToBytes(hex) {
+  const clean2 = hex.trim().toLowerCase().replace(/^0x/, "");
+  if (clean2.length === 0 || clean2.length % 2 !== 0 || /[^0-9a-f]/.test(clean2)) return null;
+  const out = new Uint8Array(clean2.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(clean2.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function base64ToBytes2(b64) {
+  const s = b64.trim().replace(/-/g, "+").replace(/_/g, "/").replace(/=+$/, "");
+  if (s.length === 0) return null;
+  const out = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const ch of s) {
+    const idx = B64_ALPHABET2.indexOf(ch);
+    if (idx === -1) return null;
+    buffer = buffer << 6 | idx;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out.push(buffer >> bits & 255);
+    }
+  }
+  return Uint8Array.from(out);
+}
+function decodeSignature(sig) {
+  const trimmed = sig.trim();
+  if (/^(0x)?[0-9a-fA-F]{128}$/.test(trimmed)) {
+    const hex2 = hexToBytes(trimmed);
+    if (hex2 && hex2.length === ED25519_SIGNATURE_BYTES) return hex2;
+  }
+  const b64 = base64ToBytes2(trimmed);
+  if (b64 && b64.length === ED25519_SIGNATURE_BYTES) return b64;
+  const hex = hexToBytes(trimmed);
+  if (hex && hex.length === ED25519_SIGNATURE_BYTES) return hex;
+  return null;
+}
+function wireSha512(ed, sha512) {
+  const concat2 = (parts) => {
+    if (parts.length === 1) return parts[0];
+    let total = 0;
+    for (const p of parts) total += p.length;
+    const out = new Uint8Array(total);
+    let off = 0;
+    for (const p of parts) {
+      out.set(p, off);
+      off += p.length;
+    }
+    return out;
+  };
+  const sync = (...msgs) => sha512(concat2(msgs));
+  const asyncFn = async (...msgs) => sha512(concat2(msgs));
+  let wired = false;
+  try {
+    if (ed.hashes && typeof ed.hashes === "object") {
+      if (typeof ed.hashes.sha512 !== "function") ed.hashes.sha512 = sync;
+      if (typeof ed.hashes.sha512Async !== "function") ed.hashes.sha512Async = asyncFn;
+      wired = typeof ed.hashes.sha512 === "function";
+    }
+  } catch {
+  }
+  try {
+    if (ed.etc && typeof ed.etc === "object") {
+      if (typeof ed.etc.sha512Sync !== "function") ed.etc.sha512Sync = sync;
+      if (typeof ed.etc.sha512Async !== "function") ed.etc.sha512Async = asyncFn;
+      wired = wired || typeof ed.etc.sha512Sync === "function";
+    }
+  } catch {
+  }
+  return wired;
+}
+function getBuiltinVerifier() {
+  if (resolved !== void 0) return resolved;
+  const ed = loadEd25519();
+  const sha512 = loadSha512();
+  if (!ed || !sha512) {
+    resolved = null;
+    return null;
+  }
+  if (!wireSha512(ed, sha512)) {
+    logger.error("[OTA] @noble/ed25519 is installed but its SHA-512 provider could not be wired (unrecognised version shape). Supply `ota.verifySignature` yourself, or pin a @noble/ed25519 version this SDK supports.");
+    resolved = null;
+    return null;
+  }
+  resolved = async ({
+    messageHex,
+    signature,
+    publicKey
+  }) => {
+    const message = hexToBytes(messageHex);
+    const pub = hexToBytes(publicKey);
+    const sig = decodeSignature(signature);
+    if (!message) {
+      logger.error("[OTA] Bundle SHA-256 is not valid hex \u2014 refusing to stage.");
+      return false;
+    }
+    if (!pub || pub.length !== ED25519_PUBLIC_KEY_BYTES) {
+      logger.error(`[OTA] ota.publicSigningKey must be ${ED25519_PUBLIC_KEY_BYTES} bytes of hex (${ED25519_PUBLIC_KEY_BYTES * 2} characters) \u2014 got ${pub ? `${pub.length} bytes` : "a value that is not hex"}.`);
+      return false;
+    }
+    if (!sig) {
+      logger.error("[OTA] Bundle signature is not a 64-byte hex/base64 value.");
+      return false;
+    }
+    try {
+      if (typeof ed.verify === "function") return ed.verify(sig, message, pub);
+      if (typeof ed.verifyAsync === "function") return await ed.verifyAsync(sig, message, pub);
+      return false;
+    } catch {
+      return false;
+    }
+  };
+  __DEV__ && logger.debug("[OTA] Using built-in ed25519 verifier (@noble/ed25519 detected).");
+  return resolved;
+}
+function _resetBuiltinVerifier() {
+  resolved = void 0;
+}
+var ED25519_SIGNATURE_BYTES, ED25519_PUBLIC_KEY_BYTES, B64_ALPHABET2, resolved;
+var init_builtinVerifier = __esm({
+  "lib/module/features/ota/crypto/builtinVerifier.js"() {
+    "use strict";
+    init_loadEd25519();
+    init_loadSha512();
+    init_internalLogger();
+    ED25519_SIGNATURE_BYTES = 64;
+    ED25519_PUBLIC_KEY_BYTES = 32;
+    B64_ALPHABET2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  }
+});
+
+// lib/module/features/ota/crypto/nativeVerifier.js
+function bytesToHex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function normalizeHex(value, expectedChars) {
+  const clean2 = value.trim().toLowerCase().replace(/^0x/, "");
+  if (clean2.length !== expectedChars || /[^0-9a-f]/.test(clean2)) return null;
+  return clean2;
+}
+function getNativeVerifier() {
+  if (resolved2 !== void 0) return resolved2;
+  const native = NativeScaleBunOta_default;
+  if (!native || typeof native.verifyEd25519 !== "function") {
+    resolved2 = null;
+    return null;
+  }
+  resolved2 = async ({
+    messageHex,
+    signature,
+    publicKey
+  }) => {
+    const message = normalizeHex(messageHex, 64);
+    const key = normalizeHex(publicKey, ED25519_PUBLIC_KEY_HEX_CHARS);
+    const sigBytes = decodeSignature(signature);
+    if (!message || !key || !sigBytes) {
+      logger.error("[OTA] Signature inputs malformed (bundle hash, signature, or public key) \u2014 refusing to stage.");
+      return false;
+    }
+    let verdict;
+    try {
+      verdict = await native.verifyEd25519(message, bytesToHex(sigBytes), key);
+    } catch (err) {
+      logger.warn(`[OTA] Native ed25519 verify failed to run: ${err?.message ?? err}`);
+      verdict = "unavailable";
+    }
+    if (verdict === "valid") return true;
+    if (verdict === "invalid") return false;
+    const builtin = getBuiltinVerifier();
+    if (builtin) {
+      return builtin({
+        messageHex,
+        signature,
+        publicKey
+      });
+    }
+    throw new Error("ed25519 unavailable: this OS has no native implementation (Android < 13) and the optional peers @noble/ed25519 + @noble/hashes are not installed.");
+  };
+  __DEV__ && logger.debug("[OTA] Using native ed25519 verifier (platform crypto).");
+  return resolved2;
+}
+var ED25519_PUBLIC_KEY_HEX_CHARS, resolved2;
+var init_nativeVerifier = __esm({
+  "lib/module/features/ota/crypto/nativeVerifier.js"() {
+    "use strict";
+    init_NativeScaleBunOta();
+    init_internalLogger();
+    init_builtinVerifier();
+    ED25519_PUBLIC_KEY_HEX_CHARS = 64;
+  }
+});
+
 // lib/module/features/ota/signature.js
 async function verifyBundleSignature(bundleSha256, signature, config) {
-  const publicKey = config?.publicKey;
-  if (!publicKey) {
+  const rawKey = config?.publicKey;
+  const keys = (Array.isArray(rawKey) ? rawKey : rawKey ? [rawKey] : []).filter((k) => typeof k === "string" && k.trim().length > 0);
+  if (rawKey === void 0 || rawKey === "" || rawKey === null) {
     if (!warnedNotConfigured) {
       warnedNotConfigured = true;
       logger.warn("[OTA] No signing public key configured \u2014 bundles are accepted on SHA-256 integrity alone. Configure `ota.publicSigningKey` to enforce authenticity.");
@@ -11594,6 +11863,13 @@ async function verifyBundleSignature(bundleSha256, signature, config) {
       reason: "not_configured"
     };
   }
+  if (keys.length === 0) {
+    logger.error("[OTA] Signing key config resolves to zero usable keys (empty array or blank strings) \u2014 refusing to stage. Remove the config to disable signing, or pin at least one real key.");
+    return {
+      ok: false,
+      reason: "no_keys"
+    };
+  }
   if (!signature) {
     logger.error("[OTA] Bundle has no signature but a signing key is configured \u2014 refusing to stage.");
     return {
@@ -11601,43 +11877,52 @@ async function verifyBundleSignature(bundleSha256, signature, config) {
       reason: "missing_signature"
     };
   }
-  if (typeof config?.verifier !== "function") {
-    logger.error("[OTA] A signing key is configured but no signature verifier is available \u2014 refusing to stage. Provide `ota.verifySignature` so signatures can be checked.");
+  const verifier = typeof config?.verifier === "function" ? config.verifier : getNativeVerifier() ?? getBuiltinVerifier();
+  if (!verifier) {
+    logger.error("[OTA] A signing key is configured but no signature verifier is available \u2014 refusing to stage. Either install the optional peers `@noble/ed25519` and `@noble/hashes` (the SDK then verifies with no further code), or provide your own `ota.verifySignature`.");
     return {
       ok: false,
       reason: "no_verifier"
     };
   }
-  try {
-    const valid = await config.verifier({
-      messageHex: bundleSha256,
-      signature,
-      publicKey
-    });
-    if (!valid) {
-      logger.error("[OTA] Bundle signature is INVALID \u2014 refusing to stage.");
-      return {
-        ok: false,
-        reason: "invalid_signature"
+  let sawThrow = false;
+  let sawCompletion = false;
+  for (const key of keys) {
+    try {
+      const valid = await verifier({
+        messageHex: bundleSha256,
+        signature,
+        publicKey: key
+      });
+      sawCompletion = true;
+      if (valid) return {
+        ok: true,
+        reason: "verified"
       };
+    } catch (err) {
+      sawThrow = true;
+      logger.error(`[OTA] Signature verifier threw: ${err?.message ?? err}`);
     }
-    return {
-      ok: true,
-      reason: "verified"
-    };
-  } catch (err) {
-    logger.error(`[OTA] Signature verifier threw: ${err?.message ?? err}`);
+  }
+  if (sawThrow && !sawCompletion) {
     return {
       ok: false,
       reason: "verifier_threw"
     };
   }
+  logger.error(keys.length > 1 ? `[OTA] Bundle signature is INVALID under all ${keys.length} pinned keys \u2014 refusing to stage.` : "[OTA] Bundle signature is INVALID \u2014 refusing to stage.");
+  return {
+    ok: false,
+    reason: "invalid_signature"
+  };
 }
 var warnedNotConfigured;
 var init_signature = __esm({
   "lib/module/features/ota/signature.js"() {
     "use strict";
     init_internalLogger();
+    init_builtinVerifier();
+    init_nativeVerifier();
     warnedNotConfigured = false;
   }
 });
@@ -12457,6 +12742,35 @@ var init_OtaOrchestrator = __esm({
   }
 });
 
+// lib/module/features/journey/uiState.js
+var uiState_exports = {};
+__export(uiState_exports, {
+  clearUiState: () => clearUiState,
+  setUiState: () => setUiState,
+  uiStateSignature: () => uiStateSignature
+});
+function setUiState(name, value) {
+  const n = clean(name);
+  const v = clean(value);
+  if (n && v) declared.set(n, v);
+}
+function clearUiState(name) {
+  if (name === void 0) declared.clear();
+  else declared.delete(clean(name));
+}
+function uiStateSignature() {
+  if (!declared.size) return void 0;
+  return [...declared.keys()].sort().map((k) => `${k}:${declared.get(k)}`).join(";").slice(0, 96);
+}
+var declared, clean;
+var init_uiState = __esm({
+  "lib/module/features/journey/uiState.js"() {
+    "use strict";
+    declared = /* @__PURE__ */ new Map();
+    clean = (s) => typeof s === "string" ? s.replace(/[;:|]/g, "").trim().slice(0, 32) : "";
+  }
+});
+
 // lib/module/features/engage/gestureTriggerDetector.js
 var gestureTriggerDetector_exports = {};
 __export(gestureTriggerDetector_exports, {
@@ -14374,6 +14688,14 @@ var SHAPE = {
         kind: "str",
         opt: true
       },
+      // Rotation support: several pinned keys, any of which may verify a
+      // bundle. Ship a build pinning [old, new], re-sign server-side with
+      // new, drop old next release — no emergency store submission when a
+      // key must be replaced. Merged with publicSigningKey by the facade.
+      publicSigningKeys: {
+        kind: "strArr",
+        opt: true
+      },
       mandatoryBlocksUi: bool(false)
     }
   }
@@ -14409,7 +14731,7 @@ function parseField(field, input, path, issues) {
       value: field.def,
       present: true
     };
-    return fail(field.kind === "bool" ? "Expected boolean, received undefined" : field.kind === "num" ? "Expected number, received undefined" : field.kind === "str" ? "Expected string, received undefined" : field.kind === "enum" ? "Invalid enum value. Expected " + field.values.map((v) => `'${v}'`).join(" | ") : "Expected object, received undefined");
+    return fail(field.kind === "bool" ? "Expected boolean, received undefined" : field.kind === "num" ? "Expected number, received undefined" : field.kind === "str" ? "Expected string, received undefined" : field.kind === "strArr" ? "Expected array, received undefined" : field.kind === "enum" ? "Invalid enum value. Expected " + field.values.map((v) => `'${v}'`).join(" | ") : "Expected object, received undefined");
   }
   switch (field.kind) {
     case "any":
@@ -14435,6 +14757,27 @@ function parseField(field, input, path, issues) {
         value: input,
         present: true
       };
+    case "strArr": {
+      if (!Array.isArray(input)) return fail(`Expected array, received ${typeofName2(input)}`);
+      let allOk = true;
+      for (let i = 0; i < input.length; i++) {
+        if (typeof input[i] !== "string") {
+          issues.push({
+            path: [...path, i],
+            message: `Expected string, received ${typeofName2(input[i])}`
+          });
+          allOk = false;
+        }
+      }
+      return allOk ? {
+        ok: true,
+        value: [...input],
+        present: true
+      } : {
+        ok: false,
+        present: true
+      };
+    }
     case "num":
       if (typeof input !== "number" || Number.isNaN(input)) {
         return fail(`Expected number, received ${typeofName2(input)}`);
@@ -15638,16 +15981,16 @@ function base64ToBytes(base64) {
   return decodeManual(base64);
 }
 function decodeManual(base64) {
-  const clean = base64.replace(/[^A-Za-z0-9+/=]/g, "");
-  const pad = clean.endsWith("==") ? 2 : clean.endsWith("=") ? 1 : 0;
-  const outLen = Math.floor(clean.length * 3 / 4) - pad;
+  const clean2 = base64.replace(/[^A-Za-z0-9+/=]/g, "");
+  const pad = clean2.endsWith("==") ? 2 : clean2.endsWith("=") ? 1 : 0;
+  const outLen = Math.floor(clean2.length * 3 / 4) - pad;
   const out = new Uint8Array(outLen);
   let p = 0;
-  for (let i = 0; i < clean.length; i += 4) {
-    const c0 = B64_ALPHABET.indexOf(clean[i]);
-    const c1 = B64_ALPHABET.indexOf(clean[i + 1]);
-    const c2 = B64_ALPHABET.indexOf(clean[i + 2]);
-    const c3 = B64_ALPHABET.indexOf(clean[i + 3]);
+  for (let i = 0; i < clean2.length; i += 4) {
+    const c0 = B64_ALPHABET.indexOf(clean2[i]);
+    const c1 = B64_ALPHABET.indexOf(clean2[i + 1]);
+    const c2 = B64_ALPHABET.indexOf(clean2[i + 2]);
+    const c3 = B64_ALPHABET.indexOf(clean2[i + 3]);
     const n = c0 << 18 | c1 << 12 | (c2 & 63) << 6 | c3 & 63;
     if (p < outLen) out[p++] = n >> 16 & 255;
     if (p < outLen) out[p++] = n >> 8 & 255;
@@ -17408,6 +17751,7 @@ var SDKBootstrapper = class {
 
 // lib/module/public/ScaleBunFacade.js
 init_EventTracker();
+init_bridgeAdapter();
 init_automaticEvents();
 
 // lib/module/analytics/eventLane.js
@@ -19834,12 +20178,17 @@ var ScaleBunFacade = class {
   /**
    * Boot the OTA orchestrator when the init config asks for it.
    *
-   * `publicSigningKey` is honoured here so signature enforcement is reachable
-   * from configuration alone. The SDK ships no ed25519 implementation, so a
-   * host that pins a key must also supply `ota.verifySignature`; pinning a key
-   * without a verifier is fail-CLOSED by design (signature.ts) — an update
-   * that cannot be verified is not installed. We say that out loud rather than
-   * letting the app discover it as a silent no-update condition.
+   * `publicSigningKey` / `publicSigningKeys` are honoured here so signature
+   * enforcement is reachable from configuration alone. The list form exists
+   * for key ROTATION: a build pinning [old, new] keeps verifying while the
+   * server moves to the new key, so replacing a key never needs an emergency
+   * store release. Both fields merge (deduplicated) into one pinned set.
+   *
+   * Verification comes from `ota.verifySignature` when supplied, else the
+   * built-in @noble-based verifier (optional peers). Pinning keys with
+   * NEITHER available is fail-CLOSED by design (signature.ts) — an update
+   * that cannot be verified is not installed. We say that out loud rather
+   * than letting the app discover it as a silent no-update condition.
    */
   _maybeStartOta(rawConfig) {
     const ota = rawConfig?.ota;
@@ -19848,15 +20197,25 @@ var ScaleBunFacade = class {
       const {
         otaOrchestrator: otaOrchestrator2
       } = (init_OtaOrchestrator(), __toCommonJS(OtaOrchestrator_exports));
-      const publicKey = ota.publicSigningKey;
+      const rawSingle = ota.publicSigningKey;
+      const rawList = ota.publicSigningKeys;
+      const publicKeys = Array.from(new Set([...typeof rawSingle === "string" && rawSingle ? [rawSingle] : [], ...Array.isArray(rawList) ? rawList : []].filter((k) => typeof k === "string" && k.trim().length > 0)));
+      const signingRequested = publicKeys.length > 0 || Array.isArray(rawList);
       const verifier = ota.verifySignature;
-      if (publicKey && typeof verifier !== "function") {
-        logger.warn("[ScaleBun] ota.publicSigningKey is set but ota.verifySignature is not a function. Signature checking is fail-closed: updates will be REJECTED until a verifier is supplied.");
+      if (signingRequested && typeof verifier !== "function") {
+        const {
+          getBuiltinVerifier: getBuiltinVerifier2
+        } = (init_builtinVerifier(), __toCommonJS(builtinVerifier_exports));
+        if (!getBuiltinVerifier2()) {
+          logger.warn("[ScaleBun] A signing key is pinned but no signature verifier is available. Signature checking is fail-closed: updates will be REJECTED until one exists. Install the optional peers `@noble/ed25519` + `@noble/hashes` (no further code needed), or supply `ota.verifySignature`.");
+        }
       }
       otaOrchestrator2.init({
-        ...publicKey ? {
+        ...signingRequested ? {
           signature: {
-            publicKey,
+            // Single key stays a plain string — the shape every
+            // existing consumer and test already handles.
+            publicKey: publicKeys.length === 1 ? publicKeys[0] : publicKeys,
             verifier
           }
         } : {},
@@ -19925,6 +20284,8 @@ var ScaleBunFacade = class {
          * the whole time. The SDK knows the device; the integrator is guessing at it.
          * Everything outside the detected keys is still theirs.
          */
+        // Everything Platform.constants knows. On iOS that is neither the model nor the
+        // manufacturer, so the bridge completes it below once it answers.
         context: mergeDeviceContext(rawConfig?.context),
         // Use the same foreground id as replay/journey capture. The
         // callback is resolved per event because the session subsystem
@@ -19938,6 +20299,7 @@ var ScaleBunFacade = class {
       });
       this._eventTracker.start();
       __DEV__ && logger.info("[ScaleBun] Envelope event tracking started \u2192 /v1/batch.");
+      this._applyNativeDeviceContext(this._eventTracker);
       this._captureInstallReferrer(this._eventTracker);
       const tracker = this._eventTracker;
       this._configManager = new ConfigManager({
@@ -19956,6 +20318,25 @@ var ScaleBunFacade = class {
       logger.warn("[ScaleBun] Failed to start envelope event tracking:", err?.message);
     }
   }
+  /**
+   * Fold the native bridge's device facts into the analytics context once it answers.
+   *
+   * Detected values never overwrite a populated one with an empty one — `nativeDeviceContext`
+   * drops absent keys and `applyDetectedContext` ignores an empty patch — so a bridge that
+   * cannot answer leaves whatever `Platform.constants` already found.
+   */
+  _applyNativeDeviceContext(tracker) {
+    Promise.resolve().then(() => bridgeAdapter.getDeviceInfo()).then((info) => {
+      if (!info) return;
+      tracker.applyDetectedContext(nativeDeviceContext({
+        osVersion: info.osVersion,
+        deviceModel: info.deviceModel
+        // iOS ships no manufacturer over the bridge; it is a constant there and the
+        // static path already set it. Android's arrives via Platform.constants.
+      }));
+    }).catch(() => {
+    });
+  }
   /**
    * Android-only: read the Play Install Referrer once per install and route it into
    * attribution. `scalebun_click_id` → the deterministic click path; the full
@@ -20046,6 +20427,46 @@ var ScaleBunFacade = class {
     };
   }
   /** Convenience: emit a Phase 1 purchase event (revenue + currency + transaction_id). */
+  /**
+   * Declare which UI state the user is looking at, so taps are attributed to the surface they
+   * happened on rather than averaged across every variant of the screen.
+   *
+   *     ScaleBun.setUiState('filter-sheet', 'open');
+   *     ScaleBun.setUiState('checkout-step', 'payment');
+   *
+   * Call it when the state CHANGES — the value is read at tap time, so it only has to be right by
+   * the time the next tap lands. On React Native this is the ONLY source of UI state: unlike the web,
+   * there is no queryable accessibility tree that says a sheet is up, and guessing would produce a
+   * state key that is right on some apps and silently wrong on others.
+   *
+   * Names and values are identifiers, not content: they become query keys in the dashboard, so a
+   * person's name or a cart total does not belong in one. `;`, `:` and `|` are stripped and both
+   * halves are capped at 32 characters.
+   */
+  setUiState(name, value) {
+    try {
+      const {
+        setUiState: setUiState2
+      } = (init_uiState(), __toCommonJS(uiState_exports));
+      setUiState2(name, value);
+    } catch {
+    }
+  }
+  /**
+   * Stop reporting a UI state dimension — or, with no argument, all of them.
+   *
+   * Clear on screen unmount. A declaration left behind follows the user onto a surface where it means
+   * nothing, and every tap there is filed under a state that was not on screen.
+   */
+  clearUiState(name) {
+    try {
+      const {
+        clearUiState: clearUiState2
+      } = (init_uiState(), __toCommonJS(uiState_exports));
+      clearUiState2(name);
+    } catch {
+    }
+  }
   trackPurchase(input) {
     noThrow(() => this._eventTracker?.trackPurchase(input));
   }
@@ -23669,11 +24090,11 @@ var normalizedWheelValue = (value) => value.toLowerCase().replace(/\s+/g, " ").t
 function resolveWheelOutcome(segments, source) {
   const identity = wheelOutcomeIdentity(source);
   const index = findWheelOutcomeIndex(segments, identity);
-  const resolved = index >= 0;
+  const resolved3 = index >= 0;
   return {
-    index: resolved ? index : 0,
-    label: identity.resultLabel || (resolved ? segments[index]?.fullLabel ?? "" : ""),
-    resolved
+    index: resolved3 ? index : 0,
+    label: identity.resultLabel || (resolved3 ? segments[index]?.fullLabel ?? "" : ""),
+    resolved: resolved3
   };
 }
 function SpinWheelInApp(props) {
@@ -32532,8 +32953,8 @@ function EngagePromptProvider({
         __DEV__ && logger.debug("[Engage] no eligible in-app message to render");
         return false;
       }
-      const resolved = selectInAppVariant(message, getDeviceId());
-      activeInAppVariantRef.current = message.experiment?.enabled ? resolved : null;
+      const resolved3 = selectInAppVariant(message, getDeviceId());
+      activeInAppVariantRef.current = message.experiment?.enabled ? resolved3 : null;
       store.recordImpression(message.id, Date.now(), message.revision);
       setActiveInApp(message);
       return true;
@@ -33241,9 +33662,22 @@ function ScaleBunDebugRoot({
           screen = AutoScreenDetector2.getInstance().getCurrentScreen() || void 0;
         } catch {
         }
+        let ui;
+        try {
+          const {
+            uiStateSignature: uiStateSignature2
+          } = (init_uiState(), __toCommonJS(uiState_exports));
+          ui = uiStateSignature2();
+        } catch {
+        }
         emitAutomaticEvent("element_interacted", {
           gesture_type: gestureType,
           screen_name: screen,
+          /* THIS MAP ENUMERATES. A field added to the payload and forgotten here reaches the
+             backend as undefined with no error anywhere — the recurring defect class in this
+             codebase. `ui` is the key the grid aggregate reads for state, byte-identical to
+             the web SDK's, so one dashboard control queries both platforms. */
+          ui,
           // testID/nativeID is an author-controlled stable identifier.
           // Accessibility labels and rendered text are deliberately omitted.
           target_id: targetInfo?.testId,