@scalebun/react-native 2.0.6 → 2.0.8

package/android/src/main/java/com/scalebun/rn/ota/ScaleBunOtaModule.kt

@@ -473,6 +473,18 @@ class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
      */
     @ReactMethod
     override fun restartApp() {
+        // Tell the boot guard this next launch is ours.
+        //
+        // Hooked HERE rather than at the JS call sites so it cannot be forgotten:
+        // every restart the SDK performs goes through this method, and each one
+        // used to spend one of the bundle's two boot attempts as though it had
+        // crashed. Recorded before the restart is dispatched, because after it
+        // there is no "after".
+        try {
+            slotManager.markIntentionalRestart()
+        } catch (e: Throwable) {
+            android.util.Log.w(NAME, "restartApp: could not record intent", e)
+        }
         val application = reactApplicationContext.applicationContext
         com.facebook.react.bridge.UiThreadUtil.runOnUiThread {
             try {

package/android/src/main/java/com/scalebun/rn/ota/SlotManager.kt

@@ -49,6 +49,27 @@ class SlotManager(private val filesDir: File) {
     private val revertRecord: File get() = File(otaRoot, REVERT_RECORD_FILENAME)
     private val sequenceFile: File get() = File(otaRoot, "highest_sequence")
 
+    /**
+     * Record that the next launch is a restart WE asked for.
+     *
+     * Consumed once by the boot guard so an intentional restart does not spend
+     * one of the bundle's two boot attempts. No-op when no boot marker is
+     * present, which is the normal steady state.
+     */
+    fun markIntentionalRestart() {
+        try {
+            if (!bootMarker.exists()) return
+            val json = JSONObject(bootMarker.readText())
+            json.put("intentionalRestart", true)
+            bootMarker.writeText(json.toString())
+            FileOutputStream(bootMarker, true).use { it.fd.sync() }
+        } catch (e: Exception) {
+            // Best effort: failing to record intent only costs a boot attempt,
+            // which is strictly better than failing the restart itself.
+            Log.w(TAG, "Could not record intentional restart", e)
+        }
+    }
+
     /**
      * Highest CONFIRMED release sequence (anti-downgrade floor, docs §15). Only
      * updated once a bundle is marked healthy, so a failed/rolled-back higher
@@ -362,6 +383,26 @@ class SlotManager(private val filesDir: File) {
             // that starts with the marker still present increments it. Reaching
             // the limit means the bundle has been given MAX_BOOT_ATTEMPTS
             // chances to call markHealthy() and never did → revert.
+            // A DELIBERATE restart is not a failed boot.
+            //
+            // The counter cannot tell "the bundle crashed on startup" from "the
+            // app restarted itself on purpose" — both simply arrive with the
+            // marker still present. So an update that installs and then restarts
+            // to activate spends one of its two lives immediately, and any second
+            // restart inside the healthy window spends the other and reverts a
+            // bundle that was never broken. Observed live: six full 19MB
+            // downloads and five reverts before one cycle happened to survive.
+            //
+            // restart() records its intent here first. That boot is expected, so
+            // it is not counted; the flag is one-shot, so a crash on the very
+            // next launch still counts and a genuinely broken bundle still goes.
+            if (markerJson.optBoolean("intentionalRestart", false)) {
+                markerJson.remove("intentionalRestart")
+                bootMarker.writeText(markerJson.toString())
+                FileOutputStream(bootMarker, true).use { it.fd.sync() }
+                Log.i(TAG, "Boot guard: expected restart, not counted as a failed boot")
+                return
+            }
             val attempts = markerJson.optInt("bootAttempts", 0) + 1
             if (attempts >= MAX_BOOT_ATTEMPTS) {
                 Log.w(

package/dist/scalebun.full.js

@@ -605,7 +605,7 @@ var SDK_VERSION;
 var init_version = __esm({
   "lib/module/core/constants/version.js"() {
     "use strict";
-    SDK_VERSION = "2.0.6";
+    SDK_VERSION = "2.0.8";
   }
 });
 

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 = "2.0.6";
+    SDK_VERSION = "2.0.8";
   }
 });
 

package/ios/Ota/OtaSlotManager.swift

@@ -44,6 +44,32 @@ class OtaSlotManager {
 
     // MARK: - Public API
 
+    /// Record that the next bridge load is a restart WE asked for.
+    ///
+    /// Consumed once by the boot guard so an intentional restart does not spend
+    /// one of the bundle's two boot attempts. No-op when no boot marker is
+    /// present, which is the normal steady state.
+    ///
+    /// Mirrors SlotManager.markIntentionalRestart() on Android. It matters more
+    /// here: checkBootGuard() runs from getBundleURL(), which React Native calls
+    /// on every bridge creation — including the reload restartApp() triggers —
+    /// so without this the activation restart ALWAYS consumes an attempt.
+    func markIntentionalRestart() {
+        let fm = FileManager.default
+        guard fm.fileExists(atPath: bootMarkerFile.path) else { return }
+        do {
+            let data = try Data(contentsOf: bootMarkerFile)
+            guard var marker = try JSONSerialization.jsonObject(with: data) as? [String: Any] else { return }
+            marker["intentionalRestart"] = true
+            let out = try JSONSerialization.data(withJSONObject: marker)
+            try out.write(to: bootMarkerFile, options: .atomic)
+        } catch {
+            // Best effort: failing to record intent only costs a boot attempt,
+            // which is strictly better than failing the restart itself.
+            NSLog("[ScaleBunOta] Could not record intentional restart: \(error)")
+        }
+    }
+
     /// Returns the URL to the active JS bundle, or nil if no OTA bundle is installed.
     func currentBundleURL() -> URL? {
         let bundle = currentSlot.appendingPathComponent(OtaSlotManager.bundleFilename)
@@ -271,6 +297,30 @@ class OtaSlotManager {
                 // still finds it increments it, and reaching the limit means the
                 // bundle has had its chances and never became healthy.
                 var marker = markerJson
+
+                // The counter cannot tell "the bundle crashed on startup" from
+                // "the app restarted itself on purpose" — both simply arrive
+                // with the marker still present. An update that installs and
+                // then restarts to activate would spend one of its two lives
+                // immediately, and any second restart inside the healthy window
+                // would spend the other and revert a bundle that was never
+                // broken. That is exactly what happened on Android before
+                // markIntentionalRestart(): six full downloads, five reverts,
+                // one cycle that happened to survive.
+                //
+                // restartApp() records its intent first. That load is expected,
+                // so it is not counted; the flag is one-shot, so a crash on the
+                // very next launch still counts and a genuinely broken bundle
+                // still goes.
+                if marker["intentionalRestart"] as? Bool == true {
+                    marker.removeValue(forKey: "intentionalRestart")
+                    if let data = try? JSONSerialization.data(withJSONObject: marker) {
+                        try? data.write(to: bootMarkerFile, options: .atomic)
+                    }
+                    NSLog("[ScaleBunOta] Boot guard: expected restart, not counted as a failed boot")
+                    return
+                }
+
                 let attempts = (marker["bootAttempts"] as? Int ?? 0) + 1
                 if attempts >= OtaSlotManager.maxBootAttempts {
                     NSLog("[ScaleBunOta] Bundle failed to become healthy in \(attempts) launch(es) — reverting")

package/ios/Ota/ScaleBunOtaModule.swift

@@ -294,6 +294,18 @@ class ScaleBunOtaModule: NSObject, RCTBridgeModule {
      */
     @objc(restartApp)
     func restartApp() {
+        // Tell the boot guard this next bridge load is ours.
+        //
+        // Hooked HERE rather than at the JS call sites so it cannot be forgotten:
+        // every restart the SDK performs goes through this method. Recorded
+        // before the reload is dispatched, because after it there is no "after".
+        //
+        // On iOS this is not merely a nicety. checkBootGuard() runs from
+        // getBundleURL(), which React Native calls on every bridge creation —
+        // and the reload below creates one. Without this flag the activation
+        // restart always spends a boot attempt, leaving a healthy bundle one
+        // relaunch away from being reverted as though it had crashed.
+        ScaleBunOtaModule.slotManager.markIntentionalRestart()
         DispatchQueue.main.async {
             RCTTriggerReloadCommandListeners("ScaleBun OTA update")
         }

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 = '2.0.6';
+const SDK_VERSION = exports.SDK_VERSION = '2.0.8';
 //# sourceMappingURL=version.js.map

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

@@ -8,5 +8,5 @@
  * value, so a stale one makes a rollout unobservable — which is the exact problem sending an SDK
  * version was introduced to solve.
  */
-export const SDK_VERSION = '2.0.6';
+export const SDK_VERSION = '2.0.8';
 //# sourceMappingURL=version.js.map

package/lib/typescript/core/constants/version.d.ts

@@ -8,5 +8,5 @@
  * value, so a stale one makes a rollout unobservable — which is the exact problem sending an SDK
  * version was introduced to solve.
  */
-export declare const SDK_VERSION = "2.0.6";
+export declare const SDK_VERSION = "2.0.8";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scalebun/react-native",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "React Native SDK for ScaleBun",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -111,7 +111,7 @@
     "@babel/runtime": "^7.25.0",
     "@jridgewell/sourcemap-codec": "1.5.5",
     "@jridgewell/trace-mapping": "0.3.31",
-    "@scalebun/cli": "^2.0.6"
+    "@scalebun/cli": "^2.0.8"
   },
   "codegenConfig": {
     "name": "ScaleBunSpec",

package/src/core/constants/version.ts

@@ -8,4 +8,4 @@
  * value, so a stale one makes a rollout unobservable — which is the exact problem sending an SDK
  * version was introduced to solve.
  */
-export const SDK_VERSION = '2.0.6';
+export const SDK_VERSION = '2.0.8';