@scalebun/react-native 1.11.0 → 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.11.0";
+    SDK_VERSION = "1.11.1";
   }
 });
 
@@ -5874,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();
@@ -7472,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.
@@ -7573,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();
@@ -7594,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})`);
@@ -7624,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
@@ -7658,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,
@@ -7676,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 {
@@ -7698,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 {
         }
       }
@@ -7799,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");
@@ -7809,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;
@@ -7833,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
             });
@@ -7846,6 +7932,7 @@ var init_OtaOrchestrator = __esm({
             };
           }
           otaEventEmitter.emitSimple("DOWNLOAD_STARTED", bundle.id, {
+            releaseId: bundle.releaseId,
             version: bundle.version
           });
           const downloadStart = Date.now();
@@ -7931,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
             });
@@ -7943,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
@@ -7951,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
             });
@@ -7964,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!`);
@@ -8016,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 {
@@ -10386,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();
@@ -16896,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;
@@ -17056,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: {
@@ -17065,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);
@@ -18485,6 +18646,7 @@ init_internalLogger();
 
 // lib/module/features/engage/engageTriggerEngine.js
 init_internalLogger();
+init_appLifecycle();
 init_AutoScreenDetector();
 init_StorageBackend();
 init_engageSignals();
@@ -18792,6 +18954,7 @@ function installEngageTriggerEngine(deps) {
 }
 
 // lib/module/features/engage/EngagePromptProvider.js
+init_appLifecycle();
 init_deviceId();
 init_api();
 init_SessionManager();
@@ -31025,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);
@@ -31034,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();

package/ios/Ota/OtaSlotManager.swift

@@ -151,10 +151,19 @@ class OtaSlotManager {
         // it `bootGuardReverted` was read by the orchestrator and written by
         // nobody on iOS, so an auto-rollback that DID occur reported nothing —
         // the dashboard counted zero rollbacks while devices were reverting.
-        let record: [String: Any] = [
+        // Stamp WHICH bundle is being reverted away from, read before current/ is
+        // removed below. Without it JS had nothing to name: slot meta carries no
+        // bundleId and the previous slot is gone by the time JS looks, so every
+        // AUTO_ROLLBACK reported bundleId "unknown" and the server dropped it as
+        // unresolvable — leaving the crash guard's rollback signal at zero.
+        var record: [String: Any] = [
             "reason": reason,
             "at": Int(Date().timeIntervalSince1970 * 1000),
         ]
+        if let meta = readMeta(slot: currentSlot),
+           let failingSha = meta["sha256"] as? String, !failingSha.isEmpty {
+            record["sha256"] = failingSha
+        }
         if let data = try? JSONSerialization.data(withJSONObject: record) {
             try? data.write(to: revertRecordFile, options: .atomic)
         }
@@ -195,14 +204,14 @@ class OtaSlotManager {
                   let markerId = (markerJson["sha256"] as? String)
                       ?? (markerJson["bundleId"] as? String) else {
                 NSLog("[ScaleBunOta] Invalid boot marker — reverting")
-                _ = revert()
+                _ = revert(reason: "invalid_marker")
                 return
             }
 
             let metaURL = currentSlot.appendingPathComponent(OtaSlotManager.metaFilename)
             guard fm.fileExists(atPath: metaURL.path) else {
                 NSLog("[ScaleBunOta] Boot marker present but no current/meta.json — reverting")
-                _ = revert()
+                _ = revert(reason: "missing_meta")
                 return
             }
 
@@ -210,7 +219,7 @@ class OtaSlotManager {
             guard let metaJson = try JSONSerialization.jsonObject(with: metaData) as? [String: Any],
                   let currentId = metaJson["sha256"] as? String else {
                 NSLog("[ScaleBunOta] Invalid current/meta.json — reverting")
-                _ = revert()
+                _ = revert(reason: "invalid_meta")
                 return
             }
 
@@ -250,7 +259,7 @@ class OtaSlotManager {
             }
         } catch {
             NSLog("[ScaleBunOta] checkBootGuard() failed — reverting: \(error)")
-            _ = revert()
+            _ = revert(reason: "boot_guard_error")
         }
     }
 
@@ -273,6 +282,11 @@ class OtaSlotManager {
                 state["bootGuardReverted"] = true
                 state["bootGuardRevertReason"] = rec["reason"] as? String ?? "boot_guard"
                 state["bootGuardRevertedAt"] = rec["at"] as? Int ?? 0
+                // The bundle reverted AWAY from. JS joins it back to a bundle id
+                // through its install record so the rollback can be reported.
+                if let sha = rec["sha256"] as? String, !sha.isEmpty {
+                    state["bootGuardRevertedSha256"] = sha
+                }
             }
             try? fm.removeItem(at: revertRecordFile)
         }

package/lib/commonjs/core/constants/version.js

@@ -14,5 +14,5 @@ exports.SDK_VERSION = void 0;
  * value, so a stale one makes a rollout unobservable — which is the exact problem sending an SDK
  * version was introduced to solve.
  */
-const SDK_VERSION = exports.SDK_VERSION = '1.11.0';
+const SDK_VERSION = exports.SDK_VERSION = '1.11.1';
 //# sourceMappingURL=version.js.map