@scalebun/react-native 1.10.7 → 1.11.1

package/dist/scalebun.slim.js

@@ -600,7 +600,7 @@ var SDK_VERSION;
 var init_version = __esm({
   "lib/module/core/constants/version.js"() {
     "use strict";
-    SDK_VERSION = "1.10.7";
+    SDK_VERSION = "1.11.1";
   }
 });
 
@@ -2459,22 +2459,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),
@@ -3574,6 +3575,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, {
@@ -3582,7 +3676,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";
@@ -3599,7 +3693,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;
@@ -3610,15 +3705,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;
@@ -4099,18 +4185,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);
@@ -4118,16 +4197,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;
         }
       }
       /**
@@ -4293,13 +4374,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
         });
       }
       /**
@@ -4307,7 +4389,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;
@@ -4315,7 +4398,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,
@@ -4353,12 +4444,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.
@@ -5772,6 +5874,42 @@ var init_bootstrap = __esm({
   }
 });
 
+// lib/module/core/lifecycle/appLifecycle.js
+var appLifecycle_exports = {};
+__export(appLifecycle_exports, {
+  appLifecycle: () => appLifecycle
+});
+var import_react_native6, AppLifecycle, appLifecycle;
+var init_appLifecycle = __esm({
+  "lib/module/core/lifecycle/appLifecycle.js"() {
+    "use strict";
+    import_react_native6 = require("react-native");
+    init_internalLogger();
+    AppLifecycle = class {
+      listeners = [];
+      currentState = import_react_native6.AppState.currentState;
+      constructor() {
+        import_react_native6.AppState.addEventListener("change", this.handleStateChange);
+      }
+      handleStateChange = (nextState) => {
+        __DEV__ && logger.debug(`App state changed: ${this.currentState} -> ${nextState}`);
+        this.currentState = nextState;
+        this.listeners.forEach((l) => l(nextState));
+      };
+      addListener(listener) {
+        this.listeners.push(listener);
+      }
+      removeListener(listener) {
+        this.listeners = this.listeners.filter((l) => l !== listener);
+      }
+      getCurrentState() {
+        return this.currentState;
+      }
+    };
+    appLifecycle = new AppLifecycle();
+  }
+});
+
 // lib/module/features/crash/CrashReporter.js
 function getCrashReporter() {
   if (!_reporter) _reporter = new CrashReporter();
@@ -6229,58 +6367,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) => {
@@ -6349,7 +6435,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) {
@@ -6453,9 +6539,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 {
@@ -6559,7 +6645,7 @@ var init_EventTracker = __esm({
         };
       }
       // ─── internals ─────────────────────────────────────────────────────────────
-      buildEnvelope(eventName, properties) {
+      buildEnvelope(eventName, properties, timestamp) {
         const ctx = this.cfg.context ?? {};
         let canonicalSessionId;
         try {
@@ -6570,7 +6656,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,
@@ -7422,6 +7508,11 @@ async function deliverOtaEvents(params) {
     kind: "ota_event",
     type: e.type,
     bundleId: e.bundleId,
+    // Without this the backend stored a null releaseId on every row it ingested,
+    // while serving the release id on every check — so the delivery funnel could
+    // only ever be grouped by bundle, and a bundle re-promoted under a second
+    // release merged the two into one indistinguishable series.
+    releaseId: e.releaseId,
     installationId: params.installationId,
     // OTA bundles are compiled per platform, so this genuinely is ios|android. Narrowed via
     // resolveMobileOS so a non-mobile RN target is skipped rather than served an Android bundle.
@@ -7523,20 +7614,31 @@ var init_OtaOrchestrator = __esm({
           this.bootGuardConfig = config ?? {};
           this.signatureConfig = config?.signature;
           __DEV__ && logger.debug(`[OTA] Orchestrator initialized (RN ${this.environment.rnVersionString ?? "unknown"}${this.environment.bridgeless ? ", bridgeless" : ""}${this.environment.hermes ? `, Hermes HBC v${this.environment.hermesBytecodeVersion ?? "?"}` : ""})`);
-          this.hydrateCurrentBundleFromSlots();
+          const slotState = this.readSlotState();
+          this.hydrateCurrentBundleFromSlots(slotState);
           void prefetchDeviceCountry();
+          this.checkBootGuardRecovery(slotState);
           this.verifyRunningBundleIdentity();
-          this.checkBootGuardRecovery();
         });
       }
       /**
        * Read the active slot back into `currentBundle` so the next check reports
        * what this device is genuinely running.
        */
-      hydrateCurrentBundleFromSlots() {
-        if (!NativeScaleBunOta_default) return;
+      /**
+       * Parse the native slot state once. Returns null when the module is absent or
+       * the payload is unreadable — every caller treats that as "factory bundle".
+       */
+      readSlotState() {
+        if (!NativeScaleBunOta_default) return null;
+        try {
+          return JSON.parse(NativeScaleBunOta_default.getSlotState());
+        } catch {
+          return null;
+        }
+      }
+      hydrateCurrentBundleFromSlots(state) {
         try {
-          const state = JSON.parse(NativeScaleBunOta_default.getSlotState());
           const current = state?.current;
           if (!current?.sha256) return;
           const record4 = this.readInstallRecord();
@@ -7544,6 +7646,7 @@ var init_OtaOrchestrator = __esm({
             this.currentBundle = {
               id: record4.bundleId,
               version: record4.version,
+              releaseId: record4.releaseId ?? void 0,
               sha256: record4.sha256
             };
             __DEV__ && logger.debug(`[OTA] Running bundle v${record4.version} (${record4.bundleId})`);
@@ -7574,29 +7677,23 @@ var init_OtaOrchestrator = __esm({
       verifyRunningBundleIdentity() {
         if (!this.currentBundle) return;
         const running = readRunningBundleMarker();
-        const expected = this.readInstallExpectation();
-        if (expected && expected.bundleId !== this.currentBundle.id) {
+        const record4 = this.readInstallRecord();
+        if (!record4) return;
+        if (record4.sha256 !== this.currentBundle.sha256) {
           this.clearInstallExpectation();
           return;
         }
-        if (expected) {
-          if (running === expected.identityToken) {
-            __DEV__ && logger.debug("[OTA] Install verified \u2014 running bundle matches what was installed.");
-            this.clearInstallExpectation();
-            return;
-          }
-          logger.error(`[OTA] INSTALL DID NOT TAKE EFFECT \u2014 bundle ${this.currentBundle.id} was installed and carries a known identity marker, but the running bundle reports ${running ?? "no marker at all"}. The app is executing different code than the slot manager believes. Check that the host app resolves the OTA bundle path at launch (see the ScaleBunOta integration for your React Native version).`);
-          otaEventEmitter.emitSimple("APPLY_FAILED", this.currentBundle.id, {
-            error: `install_not_effective \u2014 expected ${expected.identityToken}, running ${running ?? "none"}`
-          });
+        if (!record4.identityToken) return;
+        if (running === record4.identityToken) {
+          __DEV__ && logger.debug("[OTA] Install verified \u2014 running bundle matches what was installed.");
+          this.retireIdentityToken(record4);
           return;
         }
-        if (running && running !== this.currentBundle.id) {
-          logger.error(`[OTA] BUNDLE MISMATCH \u2014 slot says ${this.currentBundle.id} is active but the running bundle identifies as ${running}.`);
-          otaEventEmitter.emitSimple("APPLY_FAILED", this.currentBundle.id, {
-            error: `bundle_identity_mismatch \u2014 running ${running}`
-          });
-        }
+        logger.error(`[OTA] INSTALL DID NOT TAKE EFFECT \u2014 bundle ${this.currentBundle.id} was installed and carries a known identity marker, but the running bundle reports ${running ?? "no marker at all"}. The app is executing different code than the slot manager believes. Check that the host app resolves the OTA bundle path at launch (see the ScaleBunOta integration for your React Native version).`);
+        otaEventEmitter.emitSimple("APPLY_FAILED", this.currentBundle.id, {
+          releaseId: this.currentBundle.releaseId,
+          error: `install_not_effective \u2014 expected ${record4.identityToken}, running ${running ?? "none"}`
+        });
       }
       // ── Install expectation ────────────────────────────────────────────────────
       // Written just before the restart that activates a bundle, read on the next
@@ -7608,6 +7705,11 @@ var init_OtaOrchestrator = __esm({
           this.storage().set(_OtaOrchestrator.INSTALL_EXPECTATION_KEY, JSON.stringify({
             bundleId: bundle.id,
             version: bundle.version,
+            // Carried so telemetry emitted on a LATER launch (a boot-guard
+            // rollback, an ineffective install) can still be attributed to the
+            // release, not merely the bundle. The check response is long gone by
+            // then; this record is the only thing that remembers.
+            releaseId: bundle.releaseId ?? null,
             // The join key back to the native slot, which records sha256 and
             // nothing else identifying.
             sha256: bundle.sha256,
@@ -7626,12 +7728,26 @@ var init_OtaOrchestrator = __esm({
           return null;
         }
       }
-      readInstallExpectation() {
-        const record4 = this.readInstallRecord();
-        return record4 && record4.identityToken ? {
-          bundleId: record4.bundleId,
-          identityToken: record4.identityToken
-        } : null;
+      /**
+       * Drop the identity token once the install has been proven, keeping the rest
+       * of the record.
+       *
+       * The record does two jobs: it proves an install took effect (once), and it
+       * maps the native slot's sha256 back to a bundle id (for the life of that
+       * bundle). Only the first job is finished after a successful verification, so
+       * only the token is retired.
+       */
+      retireIdentityToken(record4) {
+        try {
+          this.storage().set(_OtaOrchestrator.INSTALL_EXPECTATION_KEY, JSON.stringify({
+            bundleId: record4.bundleId,
+            version: record4.version,
+            releaseId: record4.releaseId ?? null,
+            sha256: record4.sha256,
+            identityToken: null
+          }));
+        } catch {
+        }
       }
       clearInstallExpectation() {
         try {
@@ -7648,17 +7764,24 @@ var init_OtaOrchestrator = __esm({
        * If getSlotState() shows bootMarkerPresent=false but we have a 'previous' slot
        * and no 'current' OTA bundle, the native layer already reverted.
        */
-      checkBootGuardRecovery() {
-        if (!NativeScaleBunOta_default) return;
+      checkBootGuardRecovery(state) {
         try {
-          const stateJson = NativeScaleBunOta_default.getSlotState();
-          const state = JSON.parse(stateJson);
-          if (state.bootGuardReverted) {
-            logger.warn("[OTA] Boot guard fired \u2014 app was reverted to previous bundle");
-            otaEventEmitter.emitSimple("AUTO_ROLLBACK", state.previous?.bundleId ?? "unknown", {
-              reason: "boot_guard_crash_loop_detected"
+          if (!state?.bootGuardReverted) return;
+          const record4 = this.readInstallRecord();
+          const revertedSha = state.bootGuardRevertedSha256;
+          const matchesRecord = !!record4 && (!revertedSha || record4.sha256 === revertedSha);
+          const reason = state.bootGuardRevertReason || "boot_crash_guard";
+          if (matchesRecord && record4) {
+            logger.warn(`[OTA] Boot guard fired \u2014 reverted away from bundle ${record4.bundleId} (v${record4.version}); reason: ${reason}`);
+            otaEventEmitter.emitSimple("AUTO_ROLLBACK", record4.bundleId, {
+              releaseId: record4.releaseId ?? void 0,
+              version: record4.version,
+              reason
             });
+            this.clearInstallExpectation();
+            return;
           }
+          logger.warn(`[OTA] Boot guard fired (reason: ${reason}) but the rolled-back bundle could not be identified locally \u2014 no install record. The rollback is not reported to the server.`);
         } catch {
         }
       }
@@ -7749,6 +7872,12 @@ var init_OtaOrchestrator = __esm({
             };
           }
           __DEV__ && logger.debug("[OTA] Sync started\u2026");
+          if (this.currentBundle?.id) {
+            otaEventEmitter.emitSimple("CHECK", this.currentBundle.id, {
+              releaseId: this.currentBundle.releaseId,
+              version: this.currentBundle.version
+            });
+          }
           const checkRes = await this.checkForUpdate(params);
           if (checkRes.action === "NONE") {
             __DEV__ && logger.debug("[OTA] App is up to date");
@@ -7759,7 +7888,9 @@ var init_OtaOrchestrator = __esm({
           }
           if (checkRes.action === "ROLLBACK") {
             logger.warn("[OTA] Server requested ROLLBACK \u2014 reverting to previous bundle");
-            otaEventEmitter.emitSimple("MANUAL_ROLLBACK", this.currentBundle?.id ?? "unknown");
+            otaEventEmitter.emitSimple("MANUAL_ROLLBACK", this.currentBundle?.id ?? "unknown", {
+              releaseId: this.currentBundle?.releaseId
+            });
             const reverted = await NativeScaleBunOta_default.revertToPrevious();
             if (reverted) {
               this.currentBundle = null;
@@ -7783,9 +7914,14 @@ var init_OtaOrchestrator = __esm({
           }
           const bundle = checkRes.bundle;
           let patchUsed = false;
+          otaEventEmitter.emitSimple("OFFERED", bundle.id, {
+            releaseId: bundle.releaseId,
+            version: bundle.version
+          });
           const signatureOutcome = await verifyBundleSignature(bundle.sha256, bundle.signature, this.signatureConfig);
           if (!signatureOutcome.ok) {
             otaEventEmitter.emitSimple("APPLY_FAILED", bundle.id, {
+              releaseId: bundle.releaseId,
               error: `Signature check failed: ${signatureOutcome.reason}`,
               version: bundle.version
             });
@@ -7796,6 +7932,7 @@ var init_OtaOrchestrator = __esm({
             };
           }
           otaEventEmitter.emitSimple("DOWNLOAD_STARTED", bundle.id, {
+            releaseId: bundle.releaseId,
             version: bundle.version
           });
           const downloadStart = Date.now();
@@ -7881,6 +8018,7 @@ var init_OtaOrchestrator = __esm({
             postProgress(0, "FAILED");
             logger.error("[OTA] Staging bundle failed after retries");
             otaEventEmitter.emitSimple("APPLY_FAILED", bundle.id, {
+              releaseId: bundle.releaseId,
               error: "Staging failed \u2014 SHA-256 mismatch or download error",
               version: bundle.version
             });
@@ -7893,6 +8031,7 @@ var init_OtaOrchestrator = __esm({
           postProgress(bundle.size, "COMPLETED");
           const downloadDuration = Date.now() - downloadStart;
           otaEventEmitter.emitSimple("DOWNLOAD_COMPLETE", bundle.id, {
+            releaseId: bundle.releaseId,
             version: bundle.version,
             durationMs: downloadDuration,
             patchUsed
@@ -7901,6 +8040,7 @@ var init_OtaOrchestrator = __esm({
           if (!applied) {
             logger.error("[OTA] Applying update failed");
             otaEventEmitter.emitSimple("APPLY_FAILED", bundle.id, {
+              releaseId: bundle.releaseId,
               error: "Atomic slot swap failed",
               version: bundle.version
             });
@@ -7914,6 +8054,7 @@ var init_OtaOrchestrator = __esm({
           this.isRestartRequiredState = true;
           this.recordInstallExpectation(bundle);
           otaEventEmitter.emitSimple("INSTALLED", bundle.id, {
+            releaseId: bundle.releaseId,
             version: bundle.version
           });
           __DEV__ && logger.debug(`[OTA] Update v${bundle.version} installed successfully!`);
@@ -7966,6 +8107,14 @@ var init_OtaOrchestrator = __esm({
               NativeScaleBunOta_default?.markHealthy();
               __DEV__ && logger.info("[OTA] Boot guard cleared \u2014 bundle marked healthy \u2713");
               this.healthyTimer = null;
+              const running = this.currentBundle;
+              if (running?.id) {
+                otaEventEmitter.emitSimple("BOOT_SUCCESS", running.id, {
+                  releaseId: running.releaseId,
+                  version: running.version,
+                  durationMs: healthyMs
+                });
+              }
             });
           }, healthyMs);
         } catch {
@@ -8056,7 +8205,14 @@ function clearUiState(name) {
 }
 function uiStateSignature() {
   if (!declared.size) return void 0;
-  return [...declared.keys()].sort().map((k) => `${k}:${declared.get(k)}`).join(";").slice(0, 96);
+  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({
@@ -10329,31 +10485,8 @@ var FlushScheduler = class {
   }
 };
 
-// lib/module/core/lifecycle/appLifecycle.js
-var import_react_native6 = require("react-native");
-init_internalLogger();
-var AppLifecycle = class {
-  listeners = [];
-  currentState = import_react_native6.AppState.currentState;
-  constructor() {
-    import_react_native6.AppState.addEventListener("change", this.handleStateChange);
-  }
-  handleStateChange = (nextState) => {
-    __DEV__ && logger.debug(`App state changed: ${this.currentState} -> ${nextState}`);
-    this.currentState = nextState;
-    this.listeners.forEach((l) => l(nextState));
-  };
-  addListener(listener) {
-    this.listeners.push(listener);
-  }
-  removeListener(listener) {
-    this.listeners = this.listeners.filter((l) => l !== listener);
-  }
-  getCurrentState() {
-    return this.currentState;
-  }
-};
-var appLifecycle = new AppLifecycle();
+// lib/module/bootstrap/SDKBootstrapper.js
+init_appLifecycle();
 
 // lib/module/bootstrap/FeatureRegistry.js
 init_internalLogger();
@@ -11013,14 +11146,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.`);
         }
@@ -11030,7 +11163,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();
@@ -11347,7 +11480,7 @@ var AppLaunchCollector = class {
 };
 
 // lib/module/features/performance/collectors/ScreenLoadCollector.js
-var MAX_PENDING = 20;
+var MAX_PENDING2 = 20;
 var ScreenLoadCollector = class {
   pending = /* @__PURE__ */ new Map();
   lastScreen = null;
@@ -11362,7 +11495,7 @@ var ScreenLoadCollector = class {
    */
   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);
     }
@@ -16839,7 +16972,7 @@ async function captureInstallReferrerOnce(sink) {
 }
 
 // lib/module/public/ScaleBunFacade.js
-var ScaleBunFacade = class {
+var ScaleBunFacade = class _ScaleBunFacade {
   initialized = false;
   /** In-flight init promise — guards against a second init() racing before the first resolves. */
   _initInFlight = null;
@@ -16999,6 +17132,7 @@ var ScaleBunFacade = class {
           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`.");
         }
       }
+      const healthyAfterMs = typeof ota.healthyAfterMs === "number" ? ota.healthyAfterMs : typeof ota.healthyTimeoutMs === "number" ? ota.healthyTimeoutMs : void 0;
       otaOrchestrator2.init({
         ...signingRequested ? {
           signature: {
@@ -17008,15 +17142,99 @@ var ScaleBunFacade = class {
             verifier
           }
         } : {},
-        ...typeof ota.healthyTimeoutMs === "number" ? {
-          healthyTimeoutMs: ota.healthyTimeoutMs
+        ...healthyAfterMs !== void 0 ? {
+          healthyAfterMs
         } : {}
       });
       logger.info("[ScaleBun] OTA enabled from init config.");
+      this._startOtaChecks(ota);
     } catch (err) {
       logger.warn(`[ScaleBun] OTA init failed: ${err?.message ?? err}`);
     }
   }
+  /** Guards against overlapping config-driven OTA checks. */
+  _otaCheckInFlight = false;
+  /** Wall clock of the last config-driven check, for the foreground floor. */
+  _otaLastCheckAt = 0;
+  _otaForegroundListener = null;
+  /**
+   * Minimum gap between config-driven checks.
+   *
+   * A foreground transition is cheap to trigger — app switchers, permission
+   * dialogs and share sheets all produce one — so an unthrottled check would
+   * put a request on the hot path every time the user glanced away. Ten
+   * minutes is well below any realistic release cadence and well above that
+   * noise. A host that wants a check on demand calls `useOtaUpdate().sync()`,
+   * which is never throttled.
+   */
+  static OTA_MIN_CHECK_INTERVAL_MS = 10 * 60 * 1e3;
+  /**
+   * Drive OTA checks from init config: once at startup, then on each
+   * foreground when `checkOnForeground` is on (the schema default).
+   *
+   * `appVersion` is resolved from the native bridge rather than asked of the
+   * integrator, because it gates the server's `targetAppVersion` semver check
+   * — sending a wrong or invented value is worse than sending none, and there
+   * is no honest default. If it cannot be resolved, the check is skipped with
+   * a warning instead of guessing.
+   */
+  _startOtaChecks(ota) {
+    if (__DEV__) {
+      logger.info("[ScaleBun] OTA checks are skipped in debug builds (Metro owns the bundle).");
+      return;
+    }
+    const runCheck = async (trigger) => {
+      if (this._otaCheckInFlight) return;
+      if (trigger === "foreground" && Date.now() - this._otaLastCheckAt < _ScaleBunFacade.OTA_MIN_CHECK_INTERVAL_MS) {
+        return;
+      }
+      const clientKey = this._clientKey;
+      const apiUrl = this._apiBaseUrl;
+      if (!clientKey || !apiUrl) return;
+      this._otaCheckInFlight = true;
+      try {
+        const info = await bridgeAdapter.getDeviceInfo();
+        const appVersion = info?.appVersion;
+        if (!appVersion) {
+          logger.warn("[ScaleBun] OTA check skipped \u2014 the app version could not be read from the native bridge. Rebuild the native app, or drive checks yourself with useOtaUpdate({ appVersion }).");
+          return;
+        }
+        this._otaLastCheckAt = Date.now();
+        const {
+          otaOrchestrator: otaOrchestrator2
+        } = (init_OtaOrchestrator(), __toCommonJS(OtaOrchestrator_exports));
+        await otaOrchestrator2.sync({
+          apiUrl,
+          clientKey,
+          appVersion,
+          // The documented option, finally connected. Omitted means the
+          // server's `default` channel, exactly as before.
+          channelName: typeof ota.channelOverride === "string" ? ota.channelOverride : void 0
+          // Never forced from config: the release's own installMode
+          // decides when the app restarts, and yanking the screen out
+          // from under a user is not a decision this switch should make.
+        });
+      } catch (err) {
+        logger.warn(`[ScaleBun] OTA check failed: ${err?.message ?? err}`);
+      } finally {
+        this._otaCheckInFlight = false;
+      }
+    };
+    void runCheck("startup");
+    if (ota.checkOnForeground === false) return;
+    if (this._otaForegroundListener) return;
+    try {
+      const {
+        appLifecycle: appLifecycle2
+      } = (init_appLifecycle(), __toCommonJS(appLifecycle_exports));
+      this._otaForegroundListener = (state) => {
+        if (state === "active") void runCheck("foreground");
+      };
+      appLifecycle2.addListener(this._otaForegroundListener);
+    } catch {
+      this._otaForegroundListener = null;
+    }
+  }
   _autoEnableDebug(debugConfig) {
     try {
       const dbgConfig = buildDebugConfigFromInitConfig(debugConfig);
@@ -18428,6 +18646,7 @@ init_internalLogger();
 
 // lib/module/features/engage/engageTriggerEngine.js
 init_internalLogger();
+init_appLifecycle();
 init_AutoScreenDetector();
 init_StorageBackend();
 init_engageSignals();
@@ -18735,6 +18954,7 @@ function installEngageTriggerEngine(deps) {
 }
 
 // lib/module/features/engage/EngagePromptProvider.js
+init_appLifecycle();
 init_deviceId();
 init_api();
 init_SessionManager();
@@ -29983,7 +30203,6 @@ function useEngagePrompt() {
 // lib/module/features/journey/ScaleBunDebugRoot.js
 var import_react9 = __toESM(require("react"));
 var import_react_native42 = require("react-native");
-init_automaticEvents();
 
 // lib/module/features/journey/touchTarget.js
 var MAX_DEPTH = 12;
@@ -30055,6 +30274,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() {
@@ -30244,7 +30464,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 {
@@ -30255,9 +30477,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
@@ -30276,6 +30501,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
@@ -30308,9 +30542,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 {
@@ -30342,11 +30577,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 {
     }
   };
@@ -30377,21 +30640,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;
@@ -30422,7 +30693,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;
@@ -30440,60 +30711,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 {
-        }
-        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,
-          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 {
         }
@@ -30506,11 +30733,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 {
@@ -30527,6 +30752,7 @@ function ScaleBunDebugRoot({
           } catch {
           }
         }, 600);
+        pendingJsEmitsRef.current.set(interactionId, timer);
       }
       touchStartRef.current = null;
     } catch {
@@ -30602,20 +30828,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
@@ -30976,7 +31188,7 @@ function useOtaUpdate(options) {
     setIsSyncing(true);
     setDownloadProgress(0);
     try {
-      const result = await otaOrchestrator.sync(options);
+      const result = await otaOrchestrator.sync(optionsRef.current);
       setSyncResult(result);
       if (result.isMandatory && result.status === "UPDATE_INSTALLED" && optionsRef.current.mandatoryBlocksUi) {
         setMandatoryUpdatePending(true);
@@ -30985,7 +31197,7 @@ function useOtaUpdate(options) {
     } finally {
       setIsSyncing(false);
     }
-  }, [options.apiUrl, options.clientKey, options.appVersion, options.installationId, options.autoRestart]);
+  }, []);
   const restart = (0, import_react16.useCallback)(() => {
     setMandatoryUpdatePending(false);
     otaOrchestrator.restart();