@scalebun/react-native 1.10.6 → 1.11.0

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.6";
+    SDK_VERSION = "1.11.0";
   }
 });
 
@@ -4567,22 +4567,23 @@ var init_JourneyEventPipeline = __esm({
       emit(type, opts) {
         try {
           const key = `${type}:${opts?.subtype ?? ""}`;
-          const now2 = Date.now();
-          if (key === this.lastEventKey && now2 - this.lastEventTs < this.config.dedupeWindowMs) {
+          const receivedAt = Date.now();
+          const occurredAt = opts?.timestamp ?? receivedAt;
+          if (key === this.lastEventKey && receivedAt - this.lastEventTs < this.config.dedupeWindowMs) {
             const incomingConfidence = opts?.payload?.confidence;
             if (incomingConfidence === "high" && this.lastEventConfidence !== "high") {
-              this._replaceLastEvent(key, now2, opts);
+              this._replaceLastEvent(key, receivedAt, opts);
             }
             return null;
           }
           this.lastEventKey = key;
-          this.lastEventTs = now2;
+          this.lastEventTs = receivedAt;
           this.lastEventConfidence = opts?.payload?.confidence ?? null;
           const event = {
             eventId: generateEventId2(),
             sessionId: this.sessionId,
             journeyId: opts?.journeyId,
-            ts: now2,
+            ts: occurredAt,
             type,
             subtype: opts?.subtype,
             severity: opts?.severity ?? inferSeverity(type),
@@ -5682,6 +5683,99 @@ var init_calibrationContext = __esm({
   }
 });
 
+// lib/module/analytics/automaticEvents.js
+function compactProperties(properties) {
+  const out = {
+    capture_source: "automatic"
+  };
+  for (const [key, value] of Object.entries(properties ?? {})) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function emitAutomaticEvent(name, properties, timestamp) {
+  const event = {
+    name,
+    properties: compactProperties(properties),
+    timestamp
+  };
+  if (listeners.size === 0) {
+    pending2.push(event);
+    if (pending2.length > MAX_PENDING) pending2.shift();
+    return;
+  }
+  for (const listener of listeners) {
+    try {
+      listener(event);
+    } catch {
+    }
+  }
+}
+function subscribeAutomaticEvents(listener) {
+  listeners.add(listener);
+  if (pending2.length > 0) {
+    const buffered = pending2.splice(0, pending2.length);
+    for (const event of buffered) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  return () => {
+    listeners.delete(listener);
+  };
+}
+var listeners, pending2, MAX_PENDING;
+var init_automaticEvents = __esm({
+  "lib/module/analytics/automaticEvents.js"() {
+    "use strict";
+    listeners = /* @__PURE__ */ new Set();
+    pending2 = [];
+    MAX_PENDING = 50;
+  }
+});
+
+// lib/module/features/journey/interactionProtocol.js
+function generateInteractionId() {
+  return `ixj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function nearestInteractionStart(starts, occurredAt, toleranceMs = 1500) {
+  let best;
+  let bestDelta = toleranceMs + 1;
+  for (const start of starts) {
+    const delta = Math.abs(start.occurredAt - occurredAt);
+    if (delta < bestDelta) {
+      best = start;
+      bestDelta = delta;
+    }
+  }
+  return bestDelta <= toleranceMs ? best : void 0;
+}
+function automaticInteractionProperties(payload, screenName, canonicalMirror) {
+  return {
+    gesture_type: payload.gestureType,
+    screen_name: screenName,
+    interaction_id: payload.interaction_id,
+    interaction_protocol: payload.interaction_protocol,
+    state_status: payload.state_status,
+    ui: payload.ui,
+    target_id: payload.target_id,
+    normalized_x: payload.normalizedX,
+    normalized_y: payload.normalizedY,
+    direction: payload.direction,
+    duration_ms: payload.durationMs,
+    canonical_mirror: canonicalMirror || void 0
+  };
+}
+var INTERACTION_PROTOCOL_VERSION;
+var init_interactionProtocol = __esm({
+  "lib/module/features/journey/interactionProtocol.js"() {
+    "use strict";
+    INTERACTION_PROTOCOL_VERSION = 1;
+  }
+});
+
 // lib/module/features/session/SessionManager.js
 var SessionManager_exports = {};
 __export(SessionManager_exports, {
@@ -5690,7 +5784,7 @@ __export(SessionManager_exports, {
 function generateSessionId2() {
   return `ses-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 8)}`;
 }
-var HEATMAP_MAX_INTERACTIONS_PER_WINDOW, _instance2, SessionManager;
+var _instance2, SessionManager;
 var init_SessionManager = __esm({
   "lib/module/features/session/SessionManager.js"() {
     "use strict";
@@ -5707,7 +5801,8 @@ var init_SessionManager = __esm({
     init_redaction();
     init_calibrationContext();
     init_device();
-    HEATMAP_MAX_INTERACTIONS_PER_WINDOW = 200;
+    init_automaticEvents();
+    init_interactionProtocol();
     _instance2 = null;
     SessionManager = class _SessionManager {
       desktopTransport = null;
@@ -5718,15 +5813,6 @@ var init_SessionManager = __esm({
        * lane even when no replay recording is active. Additive, opt-in (default off).
        */
       _captureInteractionHeatmap = false;
-      /**
-       * Sampling cap for the analytics-lane heatmap emission. Now that capture is
-       * ON by default, an unbounded one-event-per-gesture stream could materially
-       * inflate ingest volume. We cap emitted interactions per analytics-session
-       * window (finalize-scoped per foreground): the first N gestures define the
-       * hotspot shape; the long tail is dropped. Resets when the window changes.
-       */
-      _heatmapWindowSessionId = null;
-      _heatmapWindowCount = 0;
       session = null;
       active = false;
       timeoutTimer = null;
@@ -6207,18 +6293,11 @@ var init_SessionManager = __esm({
        *     injected sensitive keys (e.g. a label) are stripped before transport.
        *   - Never throws.
        */
-      _emitInteractionToAnalytics(gestureType, payload) {
-        if (!this._captureInteractionHeatmap) return;
-        if (this.active) return;
+      _emitInteractionToAnalytics(gestureType, payload, occurredAt, screenName) {
+        if (!this._captureInteractionHeatmap) return false;
+        if (this.active) return false;
         const adapter = this._backendTransport;
-        if (!adapter) return;
-        const windowId = adapter.analyticsSessionId ?? "";
-        if (windowId !== this._heatmapWindowSessionId) {
-          this._heatmapWindowSessionId = windowId;
-          this._heatmapWindowCount = 0;
-        }
-        if (this._heatmapWindowCount >= HEATMAP_MAX_INTERACTIONS_PER_WINDOW) return;
-        this._heatmapWindowCount++;
+        if (!adapter) return false;
         try {
           this._normalizeInteractionPayload(payload);
           const safePayload = redactBody(payload);
@@ -6226,16 +6305,18 @@ var init_SessionManager = __esm({
             eventId: generateEventId(),
             // sessionId is (re)stamped by the analytics lane at flush time.
             sessionId: adapter.analyticsSessionId ?? "",
-            ts: Date.now(),
+            ts: occurredAt,
             type: "USER_ACTION",
             subtype: `gesture:${gestureType}`,
-            screen: this._lastKnownScreen ?? void 0,
+            screen: screenName ?? this._lastKnownScreen ?? void 0,
             payload: safePayload,
             source: "user"
           };
           adapter.trackEvent(event);
+          return true;
         } catch (err) {
           logger.error("[SessionManager] heatmap analytics emit failed:", err);
+          return false;
         }
       }
       /**
@@ -6401,13 +6482,14 @@ var init_SessionManager = __esm({
        * Notify of a user interaction. Called by ScaleBunDebugRoot touch handlers.
        * Also triggers frame capture for desktop-initiated recordings.
        */
-      onUserAction(subtype, payload) {
+      onUserAction(subtype, payload, context) {
         if (!this.active) return;
         this.emitEvent("USER_ACTION", {
           subtype,
-          screen: this._lastKnownScreen ?? void 0,
+          screen: context?.screen ?? this._lastKnownScreen ?? void 0,
           payload,
-          source: "user"
+          source: "user",
+          timestamp: context?.timestamp
         });
       }
       /**
@@ -6415,7 +6497,8 @@ var init_SessionManager = __esm({
        * Emits a USER_ACTION event with gesture-specific subtype and payload.
        */
       onGestureDetected(gestureType, details) {
-        const dedupSig = `${gestureType}|${String(details?.x)}|${String(details?.y)}|${String(details?.endX)}|${String(details?.endY)}`;
+        const suppliedInteractionId = details?.interactionId;
+        const dedupSig = suppliedInteractionId ? `id:${suppliedInteractionId}` : `${gestureType}|${String(details?.x)}|${String(details?.y)}|${String(details?.endX)}|${String(details?.endY)}`;
         const nowTs = Date.now();
         if (dedupSig === this._lastGestureSig && nowTs - this._lastGestureTs <= _SessionManager.GESTURE_DEDUP_WINDOW_MS) {
           this._lastGestureTs = nowTs;
@@ -6423,7 +6506,15 @@ var init_SessionManager = __esm({
         }
         this._lastGestureSig = dedupSig;
         this._lastGestureTs = nowTs;
+        const interactionId = suppliedInteractionId ?? generateInteractionId();
+        const occurredAt = details?.occurredAt ?? Date.now();
+        const stateStatus = details?.stateStatus ?? (details?.ui ? "captured_nonempty" : "not_captured");
         const payload = {
+          interaction_id: interactionId,
+          interaction_protocol: details?.interactionProtocol ?? INTERACTION_PROTOCOL_VERSION,
+          state_status: stateStatus,
+          ui: details?.ui,
+          target_id: details?.targetId,
           gestureType,
           x: details?.x,
           y: details?.y,
@@ -6461,12 +6552,23 @@ var init_SessionManager = __esm({
           screenHeight: details?.screenHeight,
           platform: details?.platform
         };
-        this._emitInteractionToAnalytics(gestureType, {
+        const analyticsReplayCarrier = this._emitInteractionToAnalytics(gestureType, {
           ...payload
-        });
+        }, occurredAt, details?.screenName);
+        const replayCarrier = !!this._backendTransport && (this.active || analyticsReplayCarrier);
+        if (details?.emitAutomaticAnalytics) {
+          try {
+            const safePayload = redactBody(payload);
+            emitAutomaticEvent("element_interacted", automaticInteractionProperties(safePayload, details?.screenName ?? this._lastKnownScreen ?? void 0, replayCarrier), occurredAt);
+          } catch {
+          }
+        }
         if (!this.active) return;
         const target = typeof details?.target === "string" ? details.target.trim() : "";
-        this.onUserAction(target ? `gesture:${gestureType} \xB7 ${target}` : `gesture:${gestureType}`, payload);
+        this.onUserAction(target ? `gesture:${gestureType} \xB7 ${target}` : `gesture:${gestureType}`, payload, {
+          screen: details?.screenName,
+          timestamp: occurredAt
+        });
       }
       /**
        * Manual frame capture — triggered by Desktop "Capture Step" button.
@@ -7781,12 +7883,12 @@ var init_AppLaunchCollector = __esm({
 });
 
 // lib/module/features/performance/collectors/ScreenLoadCollector.js
-var MAX_PENDING, ScreenLoadCollector;
+var MAX_PENDING2, ScreenLoadCollector;
 var init_ScreenLoadCollector = __esm({
   "lib/module/features/performance/collectors/ScreenLoadCollector.js"() {
     "use strict";
     init_models();
-    MAX_PENDING = 20;
+    MAX_PENDING2 = 20;
     ScreenLoadCollector = class {
       pending = /* @__PURE__ */ new Map();
       lastScreen = null;
@@ -7801,7 +7903,7 @@ var init_ScreenLoadCollector = __esm({
        */
       markStart(screenName) {
         if (!this.config.screenLoad) return;
-        if (this.pending.size >= MAX_PENDING) {
+        if (this.pending.size >= MAX_PENDING2) {
           const oldest = this.pending.keys().next().value;
           if (oldest) this.pending.delete(oldest);
         }
@@ -10933,58 +11035,6 @@ var init_batching = __esm({
   }
 });
 
-// lib/module/analytics/automaticEvents.js
-function compactProperties(properties) {
-  const out = {
-    capture_source: "automatic"
-  };
-  for (const [key, value] of Object.entries(properties ?? {})) {
-    if (value !== void 0) out[key] = value;
-  }
-  return out;
-}
-function emitAutomaticEvent(name, properties) {
-  const event = {
-    name,
-    properties: compactProperties(properties)
-  };
-  if (listeners.size === 0) {
-    pending3.push(event);
-    if (pending3.length > MAX_PENDING2) pending3.shift();
-    return;
-  }
-  for (const listener of listeners) {
-    try {
-      listener(event);
-    } catch {
-    }
-  }
-}
-function subscribeAutomaticEvents(listener) {
-  listeners.add(listener);
-  if (pending3.length > 0) {
-    const buffered = pending3.splice(0, pending3.length);
-    for (const event of buffered) {
-      try {
-        listener(event);
-      } catch {
-      }
-    }
-  }
-  return () => {
-    listeners.delete(listener);
-  };
-}
-var listeners, pending3, MAX_PENDING2;
-var init_automaticEvents = __esm({
-  "lib/module/analytics/automaticEvents.js"() {
-    "use strict";
-    listeners = /* @__PURE__ */ new Set();
-    pending3 = [];
-    MAX_PENDING2 = 50;
-  }
-});
-
 // lib/module/analytics/EventTracker.js
 function uuid() {
   return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
@@ -11053,7 +11103,7 @@ var init_EventTracker = __esm({
         this.started = true;
         if (this.cfg.automaticEventTracking) {
           this.automaticEventsUnsubscribe = subscribeAutomaticEvents((event) => {
-            this.track(event.name, event.properties);
+            this.track(event.name, event.properties, event.timestamp);
           });
         }
         if (this.cfg.autoLifecycleEvents) {
@@ -11157,9 +11207,9 @@ var init_EventTracker = __esm({
         }
       }
       // ─── tracking ────────────────────────────────────────────────────────────
-      track(eventName, properties) {
+      track(eventName, properties, timestamp) {
         try {
-          this.enqueue(this.buildEnvelope(eventName, properties));
+          this.enqueue(this.buildEnvelope(eventName, properties, timestamp));
           try {
             this.cfg.onEvent?.(eventName);
           } catch {
@@ -11263,7 +11313,7 @@ var init_EventTracker = __esm({
         };
       }
       // ─── internals ─────────────────────────────────────────────────────────────
-      buildEnvelope(eventName, properties) {
+      buildEnvelope(eventName, properties, timestamp) {
         const ctx = this.cfg.context ?? {};
         let canonicalSessionId;
         try {
@@ -11274,7 +11324,7 @@ var init_EventTracker = __esm({
         const env = {
           event_id: uuid(),
           event_name: eventName,
-          event_time: Date.now(),
+          event_time: timestamp ?? Date.now(),
           app_id: this.cfg.appId,
           platform: this.cfg.platform ?? resolveEventPlatform(),
           installation_id: this.installationId,
@@ -11611,10 +11661,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.");
@@ -11624,6 +11913,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 {
@@ -11631,43 +11927,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;
   }
 });
@@ -12487,6 +12792,42 @@ 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;
+  const pairs = [...declared.keys()].sort().map((k) => `${k}:${declared.get(k)}`);
+  let signature = "";
+  for (const pair of pairs) {
+    const next = signature ? `${signature};${pair}` : pair;
+    if (next.length > 96) break;
+    signature = next;
+  }
+  return signature || void 0;
+}
+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, {
@@ -14404,6 +14745,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)
     }
   }
@@ -14439,7 +14788,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":
@@ -14465,6 +14814,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)}`);
@@ -15355,14 +15725,14 @@ function installRejectionHandler(onRejection, deps) {
       allRejections: true,
       onUnhandled: (id, error) => {
         const err = toError(error);
-        pending2.set(id, err);
+        pending3.set(id, err);
         onRejection(err);
         if (isDev) {
           console.warn(`Possible unhandled promise rejection (id: ${id}):`, err?.message ?? err);
         }
       },
       onHandled: (id) => {
-        pending2.delete(id);
+        pending3.delete(id);
         if (isDev) {
           console.warn(`Promise rejection handled late (id: ${id}) \u2014 it was already reported.`);
         }
@@ -15372,7 +15742,7 @@ function installRejectionHandler(onRejection, deps) {
     return true;
   }) ?? false;
 }
-var pending2 = /* @__PURE__ */ new Map();
+var pending3 = /* @__PURE__ */ new Map();
 
 // lib/module/features/crash/CrashFeature.js
 init_CrashReporter();
@@ -15668,16 +16038,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;
@@ -19865,12 +20235,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;
@@ -19879,15 +20254,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
           }
         } : {},
@@ -20099,6 +20484,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));
   }
@@ -23722,11 +24147,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) {
@@ -32585,8 +33010,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;
@@ -32826,7 +33251,6 @@ function useEngagePrompt() {
 // lib/module/features/journey/ScaleBunDebugRoot.js
 var import_react9 = __toESM(require("react"));
 var import_react_native43 = require("react-native");
-init_automaticEvents();
 
 // lib/module/features/journey/touchTarget.js
 var MAX_DEPTH = 12;
@@ -32898,6 +33322,7 @@ function describeTouchTarget(t) {
 
 // lib/module/features/journey/ScaleBunDebugRoot.js
 init_device();
+init_interactionProtocol();
 var import_jsx_runtime8 = require("react/jsx-runtime");
 var _bootstrap = null;
 function getBootstrap() {
@@ -33087,7 +33512,9 @@ function ScaleBunDebugRoot({
   }, [navigationRef]);
   const lastNativeTouchTsRef = (0, import_react9.useRef)(0);
   const nativeTrackingConfirmedRef = (0, import_react9.useRef)(false);
-  const pendingJsEmitRef = (0, import_react9.useRef)(null);
+  const touchStartRef = (0, import_react9.useRef)(null);
+  const interactionStartsRef = (0, import_react9.useRef)([]);
+  const pendingJsEmitsRef = (0, import_react9.useRef)(/* @__PURE__ */ new Map());
   (0, import_react9.useEffect)(() => {
     let subscription = null;
     try {
@@ -33098,9 +33525,12 @@ function ScaleBunDebugRoot({
         try {
           lastNativeTouchTsRef.current = Date.now();
           nativeTrackingConfirmedRef.current = true;
-          if (pendingJsEmitRef.current !== null) {
-            clearTimeout(pendingJsEmitRef.current);
-            pendingJsEmitRef.current = null;
+          const nativeOccurredAt = typeof event.occurredAt === "number" ? event.occurredAt : (typeof event.timestamp === "number" ? event.timestamp : Date.now()) - (typeof event.durationMs === "number" ? event.durationMs : 0);
+          const start = nearestInteractionStart(interactionStartsRef.current, nativeOccurredAt);
+          if (start) {
+            const pending4 = pendingJsEmitsRef.current.get(start.interactionId);
+            if (pending4 !== void 0) clearTimeout(pending4);
+            pendingJsEmitsRef.current.delete(start.interactionId);
           }
           const {
             SessionManager: SessionManager2
@@ -33119,6 +33549,15 @@ function ScaleBunDebugRoot({
           } catch {
           }
           sm.onGestureDetected(event.gestureType || "tap", {
+            interactionId: event.interactionId || start?.interactionId || generateInteractionId(),
+            interactionProtocol: event.interactionProtocol || INTERACTION_PROTOCOL_VERSION,
+            occurredAt: nativeOccurredAt,
+            ui: start?.ui,
+            stateStatus: start?.stateStatus ?? "not_captured",
+            target: start?.target,
+            targetId: start?.targetId,
+            screenName: start?.screenName,
+            emitAutomaticAnalytics: start?.emitAutomaticAnalytics ?? captureAutomaticInteractions,
             x: event.rawX,
             y: event.rawY,
             // Use the actual native end coords when present, not the down
@@ -33151,9 +33590,10 @@ function ScaleBunDebugRoot({
         subscription?.remove();
       } catch {
       }
+      for (const timer of pendingJsEmitsRef.current.values()) clearTimeout(timer);
+      pendingJsEmitsRef.current.clear();
     };
-  }, []);
-  const touchStartRef = (0, import_react9.useRef)(null);
+  }, [captureAutomaticInteractions]);
   const rootRectRef = (0, import_react9.useRef)(null);
   const measureRoot = () => {
     try {
@@ -33185,11 +33625,39 @@ function ScaleBunDebugRoot({
   const handleTouchStart = (e) => {
     try {
       const touch = e.nativeEvent;
-      touchStartRef.current = {
+      const target = resolveTouchTarget(e);
+      let ui;
+      let screenName;
+      try {
+        const {
+          uiStateSignature: uiStateSignature2
+        } = (init_uiState(), __toCommonJS(uiState_exports));
+        ui = uiStateSignature2();
+      } catch {
+      }
+      try {
+        const {
+          AutoScreenDetector: AutoScreenDetector2
+        } = (init_AutoScreenDetector(), __toCommonJS(AutoScreenDetector_exports));
+        screenName = AutoScreenDetector2.getInstance().getCurrentScreen() || void 0;
+      } catch {
+      }
+      const start = {
+        interactionId: generateInteractionId(),
+        occurredAt: Date.now(),
         x: touch.pageX,
         y: touch.pageY,
-        ts: Date.now()
+        locationX: touch.locationX,
+        locationY: touch.locationY,
+        target: describeTouchTarget(target),
+        targetId: target?.testID,
+        screenName,
+        ui,
+        stateStatus: ui ? "captured_nonempty" : "not_instrumented",
+        emitAutomaticAnalytics: captureAutomaticInteractions
       };
+      touchStartRef.current = start;
+      interactionStartsRef.current = interactionStartsRef.current.filter((candidate) => start.occurredAt - candidate.occurredAt < 5e3).concat(start).slice(-8);
     } catch {
     }
   };
@@ -33220,21 +33688,29 @@ function ScaleBunDebugRoot({
       }
       measureRoot();
       const rootRect = rootRectRef.current;
-      const tapped = describeTouchTarget(resolveTouchTarget(e));
+      const tapped = start?.target ?? describeTouchTarget(resolveTouchTarget(e));
       const gestureDetails = {
         target: tapped,
-        x: touch.pageX,
-        y: touch.pageY,
-        pageX: touch.pageX,
-        pageY: touch.pageY,
-        locationX: touch.locationX,
-        locationY: touch.locationY,
+        interactionId: start?.interactionId ?? generateInteractionId(),
+        interactionProtocol: INTERACTION_PROTOCOL_VERSION,
+        occurredAt: start?.occurredAt ?? Date.now(),
+        ui: start?.ui,
+        stateStatus: start?.stateStatus ?? "not_captured",
+        targetId: start?.targetId,
+        screenName: start?.screenName,
+        emitAutomaticAnalytics: start?.emitAutomaticAnalytics ?? captureAutomaticInteractions,
+        x: start?.x ?? touch.pageX,
+        y: start?.y ?? touch.pageY,
+        pageX: start?.x ?? touch.pageX,
+        pageY: start?.y ?? touch.pageY,
+        locationX: start?.locationX ?? touch.locationX,
+        locationY: start?.locationY ?? touch.locationY,
         viewportWidth: vpW > 0 ? vpW : void 0,
         viewportHeight: vpH > 0 ? vpH : void 0
       };
       if (rootRect && rootRect.w > 0 && rootRect.h > 0) {
-        const nx = Math.max(0, Math.min(1, touch.pageX / rootRect.w));
-        const ny = Math.max(0, Math.min(1, touch.pageY / rootRect.h));
+        const nx = Math.max(0, Math.min(1, (start?.x ?? touch.pageX) / rootRect.w));
+        const ny = Math.max(0, Math.min(1, (start?.y ?? touch.pageY) / rootRect.h));
         gestureDetails.normalizedX = nx;
         gestureDetails.normalizedY = ny;
         gestureDetails.normalizedPrecomputed = true;
@@ -33265,7 +33741,7 @@ function ScaleBunDebugRoot({
         const dx = touch.pageX - start.x;
         const dy = touch.pageY - start.y;
         const dist = Math.sqrt(dx * dx + dy * dy);
-        const duration = Date.now() - start.ts;
+        const duration = Date.now() - start.occurredAt;
         gestureDetails.duration = duration;
         if (dist >= 15) {
           gestureDetails.endX = touch.pageX;
@@ -33283,47 +33759,16 @@ function ScaleBunDebugRoot({
           gestureType = "long_press";
         }
       }
-      const targetInfo = _extractTarget(e);
-      gestureDetails.target = targetInfo?.testId || targetInfo?.accessibilityLabel;
-      if (captureAutomaticInteractions) {
-        let screen;
-        try {
-          const {
-            AutoScreenDetector: AutoScreenDetector2
-          } = (init_AutoScreenDetector(), __toCommonJS(AutoScreenDetector_exports));
-          screen = AutoScreenDetector2.getInstance().getCurrentScreen() || void 0;
-        } catch {
-        }
-        emitAutomaticEvent("element_interacted", {
-          gesture_type: gestureType,
-          screen_name: screen,
-          // testID/nativeID is an author-controlled stable identifier.
-          // Accessibility labels and rendered text are deliberately omitted.
-          target_id: targetInfo?.testId,
-          normalized_x: gestureDetails.normalizedX,
-          normalized_y: gestureDetails.normalizedY,
-          direction: gestureDetails.direction,
-          duration_ms: gestureDetails.duration
-        });
-      }
       if (gestureType === "tap") {
         try {
           const {
             gestureTriggerDetector: gestureTriggerDetector2
           } = (init_gestureTriggerDetector(), __toCommonJS(gestureTriggerDetector_exports));
-          let screen;
-          try {
-            const {
-              AutoScreenDetector: AutoScreenDetector2
-            } = (init_AutoScreenDetector(), __toCommonJS(AutoScreenDetector_exports));
-            screen = AutoScreenDetector2.getInstance().getCurrentScreen() || void 0;
-          } catch {
-          }
           gestureTriggerDetector2.recordTap({
-            x: touch.pageX,
-            y: touch.pageY,
-            hasTarget: !!(targetInfo?.testId || targetInfo?.accessibilityLabel),
-            screen
+            x: start?.x ?? touch.pageX,
+            y: start?.y ?? touch.pageY,
+            hasTarget: !!(start?.targetId || start?.target),
+            screen: start?.screenName
           });
         } catch {
         }
@@ -33336,11 +33781,9 @@ function ScaleBunDebugRoot({
         const capturedDetails = {
           ...gestureDetails
         };
-        if (pendingJsEmitRef.current !== null) {
-          clearTimeout(pendingJsEmitRef.current);
-        }
-        pendingJsEmitRef.current = setTimeout(() => {
-          pendingJsEmitRef.current = null;
+        const interactionId = capturedDetails.interactionId;
+        const timer = setTimeout(() => {
+          pendingJsEmitsRef.current.delete(interactionId);
           if (nativeTrackingConfirmedRef.current) return;
           try {
             const {
@@ -33357,6 +33800,7 @@ function ScaleBunDebugRoot({
           } catch {
           }
         }, 600);
+        pendingJsEmitsRef.current.set(interactionId, timer);
       }
       touchStartRef.current = null;
     } catch {
@@ -33432,20 +33876,6 @@ function useScaleBunScreen(name) {
     }
   }, [name, manager]);
 }
-function _extractTarget(e) {
-  try {
-    const target = e?.target;
-    if (!target) return void 0;
-    const props = target._internalFiberInstanceHandleDEV?.memoizedProps ?? {};
-    return {
-      testId: props.testID || props.nativeID || void 0,
-      accessibilityLabel: props.accessibilityLabel || void 0,
-      text: void 0
-    };
-  } catch {
-    return void 0;
-  }
-}
 var styles4 = {
   root: {
     flex: 1