@hot-updater/react-native 1.0.0-rc.34 → 1.0.0-rc.35

package/android/build.gradle

@@ -20,8 +20,12 @@ def reactNativeArchitectures() {
   return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
+// The New Architecture is the default. React Native 0.82 and later run nothing
+// else and set newArchEnabled to true on every library project, whatever the
+// app's gradle.properties says, so only an older React Native app that sets
+// newArchEnabled=false builds the old architecture.
 def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+  return !project.hasProperty("newArchEnabled") || project.property("newArchEnabled").toString().toBoolean()
 }
 
 apply plugin: "com.android.library"
@@ -115,7 +119,11 @@ android {
           "src/newarch",
           // Codegen specs
           "generated/java",
-          "generated/jni"
+          "generated/jni",
+          // React Native 0.81 and older can run the New Architecture on the
+          // bridge. Later versions have none, so their builds never compile
+          // ReactNativeHost.
+          project.ext.reactNativeMinorVersion >= 82 ? "src/bridgeless" : "src/bridge"
         ]
       }
     }
@@ -146,6 +154,9 @@ dependencies {
   }
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.1"
+  // ProcessLifecycleOwner, for an activity that started before Hot Updater was created.
+  // React Native's AppCompat already brings it at runtime.
+  implementation "androidx.lifecycle:lifecycle-process:2.6.1"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
   implementation "org.apache.commons:commons-compress:1.27.1"

package/android/proguard-rules.pro

@@ -6,15 +6,6 @@
 }
 
 # New Architecture
-# Crash recovery discovers these accessors through reflection.
--keepclassmembers class * implements com.facebook.react.ReactApplication {
-    public *** getReactHost();
-}
-
--keepclassmembers class * implements com.facebook.react.ReactHost {
-    public *** getCurrentReactContext();
-}
-
 # Keep fields accessed via reflection in ReactHost
 # Support both Java (mReactHostDelegate) and Kotlin (reactHostDelegate) field names
 -keepclassmembers class com.facebook.react.runtime.ReactHostImpl {

package/android/src/bridge/BridgeReactInstance.kt

@@ -0,0 +1,38 @@
+package com.hotupdater
+
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSBundleLoader
+
+/**
+ * React Native 0.81 and older can run the New Architecture on the bridge, which
+ * only ReactNativeHost reaches. Only builds for those versions compile this file.
+ */
+internal object BridgeReactInstance {
+    fun setJSBundle(
+        application: ReactApplication,
+        bundleLoader: JSBundleLoader?,
+    ) {
+        @Suppress("DEPRECATION")
+        val instanceManager = application.reactNativeHost.reactInstanceManager
+        val bundleLoaderField = instanceManager::class.java.getDeclaredField("mBundleLoader")
+        bundleLoaderField.isAccessible = true
+        bundleLoaderField.set(instanceManager, bundleLoader)
+    }
+
+    fun reload(application: ReactApplication) {
+        @Suppress("DEPRECATION")
+        val reactNativeHost = application.reactNativeHost
+        try {
+            reactNativeHost.reactInstanceManager.recreateReactContextInBackground()
+        } catch (e: Exception) {
+            val currentActivity = reactNativeHost.reactInstanceManager.currentReactContext?.currentActivity
+            if (currentActivity == null) {
+                return
+            }
+
+            currentActivity.runOnUiThread {
+                currentActivity.recreate()
+            }
+        }
+    }
+}

package/android/src/bridgeless/BridgeReactInstance.kt

@@ -0,0 +1,24 @@
+package com.hotupdater
+
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSBundleLoader
+
+/**
+ * React Native 0.82 and later have no bridge, so an app without a ReactHost has
+ * no instance to update. Builds for those versions compile this file instead of
+ * the bridge one, and never reference ReactNativeHost.
+ */
+@Suppress("UNUSED_PARAMETER")
+internal object BridgeReactInstance {
+    fun setJSBundle(
+        application: ReactApplication,
+        bundleLoader: JSBundleLoader?,
+    ) {
+        Log.d("HotUpdater", "No ReactHost to set the JS bundle on")
+    }
+
+    fun reload(application: ReactApplication) {
+        Log.d("HotUpdater", "No ReactHost to reload")
+    }
+}

package/android/src/main/java/com/hotupdater/ActivityStartGate.kt

@@ -0,0 +1,94 @@
+package com.hotupdater
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ProcessLifecycleOwner
+
+/**
+ * Runs an action once this process has a started activity.
+ *
+ * A headless JS task (HeadlessJsTaskService, which background push libraries
+ * start) loads the bundle with no activity and never renders. Waiting for an
+ * activity keeps that launch from counting as one that ended before its first
+ * render.
+ *
+ * Android does not replay lifecycle callbacks to a late registration. An
+ * activity that started before this gate existed, as when a brownfield app adds
+ * React Native to an activity already on screen, is read from
+ * [processHasStartedActivity] instead.
+ */
+internal class ActivityStartGate(
+    private val application: Application?,
+    private val processHasStartedActivity: () -> Boolean = ::hasStartedActivity,
+) : Application.ActivityLifecycleCallbacks {
+    private var startedActivities = 0
+    private var pendingAction: (() -> Unit)? = null
+
+    init {
+        application?.registerActivityLifecycleCallbacks(this)
+    }
+
+    /**
+     * Runs [action] now when an activity is started, otherwise at the next
+     * activity start. It replaces an action still waiting; null cancels it.
+     * Without an application to observe, it runs [action] now.
+     */
+    fun runWhenActivityStarted(action: (() -> Unit)?) {
+        val runNow =
+            synchronized(this) {
+                val waits =
+                    application != null &&
+                        startedActivities == 0 &&
+                        !processHasStartedActivity()
+                pendingAction = action.takeIf { waits }
+                action.takeUnless { waits }
+            }
+        runNow?.invoke()
+    }
+
+    override fun onActivityStarted(activity: Activity) {
+        val action =
+            synchronized(this) {
+                startedActivities += 1
+                pendingAction.also { pendingAction = null }
+            }
+        action?.invoke()
+    }
+
+    override fun onActivityStopped(activity: Activity) {
+        synchronized(this) {
+            // An activity started before this gate existed was never counted.
+            if (startedActivities > 0) startedActivities -= 1
+        }
+    }
+
+    override fun onActivityCreated(
+        activity: Activity,
+        savedInstanceState: Bundle?,
+    ) {}
+
+    override fun onActivityResumed(activity: Activity) {}
+
+    override fun onActivityPaused(activity: Activity) {}
+
+    override fun onActivitySaveInstanceState(
+        activity: Activity,
+        outState: Bundle,
+    ) {}
+
+    override fun onActivityDestroyed(activity: Activity) {}
+}
+
+// ProcessLifecycleOwner observes activities from process start, through the
+// androidx.startup initializer that lifecycle-process registers. It is STARTED
+// while an activity of this process is started, and stays at INITIALIZED when
+// an app removes that initializer, so the gate then waits for the next start.
+private fun hasStartedActivity(): Boolean =
+    runCatching {
+        ProcessLifecycleOwner
+            .get()
+            .lifecycle.currentState
+            .isAtLeast(Lifecycle.State.STARTED)
+    }.getOrDefault(false)

package/android/src/main/java/com/hotupdater/BundleFileStorageService.kt

@@ -151,6 +151,12 @@ interface BundleStorageService {
 
     suspend fun commitReleaseSelection(selection: PersistedSelection): Boolean = false
 
+    /**
+     * Records that the current launch of a verification-pending bundle can show UI.
+     * The next process rolls the bundle back unless first content verified it.
+     */
+    fun markLaunchStarted(launchedBundleId: String?)
+
     /**
      * Marks the current launch as successful after the first content appeared.
      */
@@ -162,7 +168,8 @@ interface BundleStorageService {
     fun notifyAppReady(): Map<String, Any?>
 
     /**
-     * Gets the crashed bundle history
+     * Gets the crashed bundle history, plus a bundle that waits for its retry after
+     * an unfinished launch while this process still refuses it (see [InterruptedLaunch])
      * @return CrashedHistory containing crashed bundles
      */
     fun getCrashHistory(): CrashedHistory
@@ -592,6 +599,16 @@ class BundleFileStorageService(
     private var hasPreparedLaunch = false
     private var currentLaunchReport: LaunchReport? = null
 
+    // The staged bundle this process launched before its first content. Only that
+    // launch is pending; a bundle staged later waits for the next launch.
+    private var pendingLaunchBundleId: String? = null
+
+    // Crash history is written at first content on the main thread while JS can read it.
+    private val crashedHistoryLock = Any()
+
+    // A bundle waiting for its retry that this process keeps refusing, see InterruptedLaunch.
+    private var retryHeldBundleId: String? = null
+
     @Volatile
     private var activeBundleMetadataSnapshot: ActiveBundleMetadataSnapshot? = null
     private val activeBundleMetadataLock = Any()
@@ -1092,7 +1109,14 @@ class BundleFileStorageService(
         )
     }
 
-    private fun rollbackPendingBundle(stagingBundleId: String): Boolean {
+    /**
+     * Rolls back the pending staging bundle. [unfinishedLaunch] means its launch
+     * ended before first content without a crash marker.
+     */
+    private fun rollbackPendingBundle(
+        stagingBundleId: String,
+        unfinishedLaunch: Boolean = false,
+    ): Boolean {
         val metadata = loadMetadataOrNull() ?: return false
         if (metadata.stagingBundleId != stagingBundleId) {
             return false
@@ -1100,9 +1124,7 @@ class BundleFileStorageService(
 
         Log.w(TAG, "Rolling back crashed staging bundle: $stagingBundleId")
 
-        val crashedHistory = loadCrashedHistory()
-        crashedHistory.addEntry(stagingBundleId)
-        saveCrashedHistory(crashedHistory)
+        recordFailedLaunch(stagingBundleId, unfinishedLaunch)
 
         val fallbackBundleId =
             metadata.stableBundleId?.takeIf { candidate ->
@@ -1369,18 +1391,98 @@ class BundleFileStorageService(
 
     private fun saveCrashedHistory(history: CrashedHistory): Boolean = history.saveToFile(getCrashedHistoryFile())
 
-    private fun isBundleInCrashedHistory(bundleId: String): Boolean = loadCrashedHistory().contains(bundleId)
+    private fun isBundleInCrashedHistory(bundleId: String): Boolean = getCrashHistory().contains(bundleId)
 
-    override fun getCrashHistory(): CrashedHistory = loadCrashedHistory()
+    /**
+     * The bundles this device refuses to install: crash history, plus a bundle
+     * waiting for its retry until a process that may retry it.
+     */
+    override fun getCrashHistory(): CrashedHistory =
+        synchronized(crashedHistoryLock) {
+            val history = loadCrashedHistory()
+            val interrupted = history.interruptedLaunch
+            if (interrupted != null &&
+                (!interrupted.retryReady || interrupted.bundleId == retryHeldBundleId) &&
+                !history.contains(interrupted.bundleId)
+            ) {
+                history.bundles.add(CrashedBundleEntry(interrupted.bundleId, crashedAt = System.currentTimeMillis()))
+            }
+            history
+        }
 
     override fun clearCrashHistory(): Boolean {
-        val history = CrashedHistory()
-        saveCrashedHistory(history)
+        synchronized(crashedHistoryLock) {
+            saveCrashedHistory(CrashedHistory())
+            retryHeldBundleId = null
+        }
         Log.d(TAG, "Cleared crash history")
         return true
     }
 
+    /**
+     * A crash, or a second unfinished launch of the same bundle, adds the bundle to
+     * crash history. A first unfinished launch cannot tell a hang from a user leaving
+     * early, so it leaves the bundle one retry instead.
+     */
+    private fun recordFailedLaunch(
+        bundleId: String,
+        unfinishedLaunch: Boolean,
+    ) {
+        synchronized(crashedHistoryLock) {
+            val history = loadCrashedHistory()
+            val interrupted = history.interruptedLaunch
+            if (unfinishedLaunch && interrupted?.bundleId != bundleId) {
+                Log.w(TAG, "Launch of $bundleId ended before first content; it gets one retry")
+                history.interruptedLaunch = InterruptedLaunch(bundleId)
+                retryHeldBundleId = bundleId
+            } else {
+                history.addEntry(bundleId)
+                if (interrupted?.bundleId == bundleId) {
+                    history.interruptedLaunch = null
+                }
+            }
+            saveCrashedHistory(history)
+        }
+    }
+
+    /**
+     * First content appeared, so the app works again. A bundle waiting for its retry
+     * may be installed from the next process on. This process keeps refusing it, so
+     * the session that recovered never reloads into it. Content from that bundle
+     * verifies it.
+     */
+    private fun readyInterruptedLaunchRetry(currentBundleId: String?) {
+        synchronized(crashedHistoryLock) {
+            val history = loadCrashedHistory()
+            val interrupted = history.interruptedLaunch ?: return
+            if (interrupted.bundleId == currentBundleId) {
+                history.interruptedLaunch = null
+            } else if (interrupted.retryReady) {
+                return
+            } else {
+                history.interruptedLaunch = interrupted.copy(retryReady = true)
+                retryHeldBundleId = interrupted.bundleId
+            }
+            saveCrashedHistory(history)
+        }
+    }
+
+    override fun markLaunchStarted(launchedBundleId: String?) {
+        // Unlike prepareLaunch, this can run while JS stages a newer bundle.
+        synchronized(releaseStateLock) {
+            val metadata = loadMetadataOrNull() ?: return
+            if (!isVerificationPending(metadata) ||
+                metadata.launchInProgress ||
+                metadata.stagingBundleId != launchedBundleId
+            ) {
+                return
+            }
+            saveMetadata(metadata.copy(launchInProgress = true))
+        }
+    }
+
     override fun markLaunchCompleted(currentBundleId: String?) {
+        readyInterruptedLaunchRetry(currentBundleId)
         val metadata = loadMetadataOrNull() ?: return
         val stagingBundleId = metadata.stagingBundleId ?: return
         if (!metadata.verificationPending || stagingBundleId != currentBundleId) {
@@ -1418,7 +1520,11 @@ class BundleFileStorageService(
         val report = loadLaunchReport()
         if (report == null) {
             val metadata = loadMetadataOrNull()
-            if (metadata?.verificationPending == true && metadata.stagingBundleId != null) {
+            val launchedBundleId = pendingLaunchBundleId
+            if (launchedBundleId != null &&
+                metadata?.verificationPending == true &&
+                metadata.stagingBundleId == launchedBundleId
+            ) {
                 return mapOf("status" to "PENDING")
             }
             return mapOf("status" to "UNCHANGED")
@@ -1483,17 +1589,14 @@ class BundleFileStorageService(
         if (!hasPreparedLaunch) {
             val metadata = loadMetadataOrNull()
             if (metadata?.verificationPending == true && metadata.launchInProgress) {
-                metadata.stagingBundleId?.let { rollbackPendingBundle(it) }
+                metadata.stagingBundleId?.let { rollbackPendingBundle(it, unfinishedLaunch = true) }
             }
         }
         hasPreparedLaunch = true
 
+        // A launch is recorded only once it can show UI (markLaunchStarted).
         val selection = selectLaunch()
-        if (selection.shouldRollbackOnCrash) {
-            loadMetadataOrNull()?.let { metadata ->
-                saveMetadata(metadata.copy(launchInProgress = true))
-            }
-        }
+        pendingLaunchBundleId = selection.launchedBundleId.takeIf { selection.shouldRollbackOnCrash }
         Log.d(
             TAG,
             "prepareLaunch: bundleId=${selection.launchedBundleId} shouldRollback=${selection.shouldRollbackOnCrash} url=${selection.bundleUrl}",

package/android/src/main/java/com/hotupdater/BundleMetadata.kt

@@ -296,12 +296,44 @@ data class CrashedBundleEntry(
         }
 }
 
+/**
+ * A bundle whose launch ended before first content without a crash, waiting
+ * for its one retry. Such a launch cannot tell a hang from a user leaving
+ * early, so the bundle is offered again instead of entering crash history.
+ * A second unfinished launch of it adds it there.
+ *
+ * [retryReady] turns true once a later launch shows content. The retry
+ * starts with the next process, so the session that recovered never reloads
+ * into the same bundle.
+ */
+data class InterruptedLaunch(
+    val bundleId: String,
+    val retryReady: Boolean = false,
+) {
+    companion object {
+        fun fromJson(json: JSONObject): InterruptedLaunch? =
+            json.optNullableString("bundleId")?.let { bundleId ->
+                InterruptedLaunch(
+                    bundleId = bundleId,
+                    retryReady = json.optBoolean("retryReady", false),
+                )
+            }
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("bundleId", bundleId)
+            put("retryReady", retryReady)
+        }
+}
+
 /**
  * History of crashed bundles
  */
 data class CrashedHistory(
     val bundles: MutableList<CrashedBundleEntry> = mutableListOf(),
     val maxHistorySize: Int = DEFAULT_MAX_HISTORY_SIZE,
+    var interruptedLaunch: InterruptedLaunch? = null,
 ) {
     companion object {
         private const val TAG = "CrashedHistory"
@@ -317,6 +349,7 @@ data class CrashedHistory(
             return CrashedHistory(
                 bundles = bundles,
                 maxHistorySize = json.optInt("maxHistorySize", DEFAULT_MAX_HISTORY_SIZE),
+                interruptedLaunch = json.optJSONObject("interruptedLaunch")?.let(InterruptedLaunch::fromJson),
             )
         }
 
@@ -342,6 +375,7 @@ data class CrashedHistory(
             bundles.forEach { bundlesArray.put(it.toJson()) }
             put("bundles", bundlesArray)
             put("maxHistorySize", maxHistorySize)
+            interruptedLaunch?.let { put("interruptedLaunch", it.toJson()) }
         }
 
     fun saveToFile(file: File): Boolean =
@@ -389,6 +423,7 @@ data class CrashedHistory(
 
     fun clear() {
         bundles.clear()
+        interruptedLaunch = null
     }
 }
 

package/android/src/main/java/com/hotupdater/HotUpdaterImpl.kt

@@ -1,6 +1,7 @@
 package com.hotupdater
 
 import android.app.ActivityOptions
+import android.app.Application
 import android.content.Context
 import android.content.Intent
 import android.os.Process
@@ -20,6 +21,7 @@ class HotUpdaterImpl {
     private val releaseCatalogCache: ReleaseCatalogCacheService
     private val installIdentity: InstallIdentityService
     private val keyValueStorage: KeyValueStorageService
+    private val activityStartGate: ActivityStartGate
     private var currentLaunchSelection: LaunchSelection? = null
 
     /**
@@ -33,6 +35,7 @@ class HotUpdaterImpl {
         this.context = context.applicationContext
         this.bundleStorage = bundleStorage
         this.preferences = preferences
+        this.activityStartGate = ActivityStartGate(this.context as? Application)
         this.recoveryManager = HotUpdaterRecoveryManager(this.context)
         this.releaseCatalogCache =
             ReleaseCatalogCacheService(
@@ -508,6 +511,16 @@ class HotUpdaterImpl {
 
         val pendingRecovery = recoveryManager.consumePendingCrashRecovery()
         val selection = bundleStorage.prepareLaunch(pendingRecovery)
+        // A headless JS task, such as a background push, loads the bundle without
+        // an activity and never renders. Only a launch with an activity may leave
+        // an unfinished launch for the next process to roll back.
+        activityStartGate.runWhenActivityStarted(
+            if (selection.shouldRollbackOnCrash) {
+                { bundleStorage.markLaunchStarted(selection.launchedBundleId) }
+            } else {
+                null
+            },
+        )
         recoveryManager.startMonitoring(
             bundleId = selection.launchedBundleId,
             shouldRollback = selection.shouldRollbackOnCrash,

package/android/src/main/java/com/hotupdater/HotUpdaterRecoveryManager.kt

@@ -234,141 +234,11 @@ internal class HotUpdaterRecoveryManager(
         }
     }
 
+    // Each architecture's source set reaches its own React instance, so the old
+    // architecture's ReactNativeHost is compiled only into old architecture builds.
     private fun installJavaScriptExceptionHooks() {
         val application = appContext as? ReactApplication ?: return
-
-        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-            installReactHostExceptionHook(application)
-        } else {
-            installLegacyExceptionHook(application)
-        }
-    }
-
-    private fun installReactHostExceptionHook(application: ReactApplication) {
-        val reactHost = getReactHost(application) ?: return
-        val reactHostDelegate =
-            findField(reactHost.javaClass, "mReactHostDelegate")?.let { field ->
-                field.isAccessible = true
-                field.get(reactHost)
-            }
-                ?: findField(reactHost.javaClass, "reactHostDelegate")?.let { field ->
-                    field.isAccessible = true
-                    field.get(reactHost)
-                }
-                ?: return
-
-        val delegateIdentity = System.identityHashCode(reactHostDelegate)
-        if (patchedReactHostDelegateIds.add(delegateIdentity)) {
-            val exceptionHandlerField = findField(reactHostDelegate.javaClass, "exceptionHandler")
-            if (exceptionHandlerField == null) {
-                patchedReactHostDelegateIds.remove(delegateIdentity)
-                return
-            }
-
-            exceptionHandlerField.isAccessible = true
-            @Suppress("UNCHECKED_CAST")
-            val previousHandler =
-                exceptionHandlerField.get(reactHostDelegate) as? (Exception) -> Unit
-
-            exceptionHandlerField.set(reactHostDelegate) { exception: Exception ->
-                if (activeManager?.handleJavaScriptException(exception) != true) {
-                    previousHandler?.invoke(exception) ?: throw exception
-                }
-            }
-        }
-
-        val reactContext =
-            findMethod(reactHost.javaClass, "getCurrentReactContext")?.invoke(reactHost) as? ReactContext
-        reactContext?.let { patchReactContextExceptionHandler(it) }
-    }
-
-    private fun installLegacyExceptionHook(application: ReactApplication) {
-        val instanceManager = application.reactNativeHost.reactInstanceManager
-        val managerIdentity = System.identityHashCode(instanceManager)
-        if (patchedInstanceManagerIds.add(managerIdentity)) {
-            val exceptionHandlerField = findField(instanceManager.javaClass, "mJSExceptionHandler")
-            if (exceptionHandlerField == null) {
-                patchedInstanceManagerIds.remove(managerIdentity)
-                return
-            }
-
-            exceptionHandlerField.isAccessible = true
-            val previousHandler = exceptionHandlerField.get(instanceManager) as? JSExceptionHandler
-            exceptionHandlerField.set(instanceManager, RecoveryJSExceptionHandler(previousHandler))
-        }
-
-        instanceManager.currentReactContext?.let { reactContext ->
-            patchReactContextExceptionHandler(reactContext)
-            patchCatalystInstanceExceptionHandler(reactContext)
-        }
-    }
-
-    private fun patchReactContextExceptionHandler(reactContext: ReactContext) {
-        val contextIdentity = System.identityHashCode(reactContext)
-        if (!patchedReactContextIds.add(contextIdentity)) {
-            return
-        }
-
-        val previousHandler = reactContext.jsExceptionHandler
-        if (previousHandler is RecoveryJSExceptionHandler) {
-            return
-        }
-
-        reactContext.setJSExceptionHandler(RecoveryJSExceptionHandler(previousHandler))
-    }
-
-    private fun patchCatalystInstanceExceptionHandler(reactContext: ReactContext) {
-        val catalystInstance =
-            try {
-                reactContext.catalystInstance
-            } catch (_: Exception) {
-                null
-            } ?: return
-
-        val catalystIdentity = System.identityHashCode(catalystInstance)
-        if (!patchedCatalystInstanceIds.add(catalystIdentity)) {
-            return
-        }
-
-        val exceptionHandlerField = findField(catalystInstance.javaClass, "mJSExceptionHandler")
-        if (exceptionHandlerField == null) {
-            patchedCatalystInstanceIds.remove(catalystIdentity)
-            return
-        }
-
-        exceptionHandlerField.isAccessible = true
-        val previousHandler = exceptionHandlerField.get(catalystInstance) as? JSExceptionHandler
-        if (previousHandler is RecoveryJSExceptionHandler) {
-            return
-        }
-        exceptionHandlerField.set(catalystInstance, RecoveryJSExceptionHandler(previousHandler))
-    }
-
-    private fun getReactHost(application: ReactApplication): Any? =
-        try {
-            findMethod(application.javaClass, "getReactHost")?.invoke(application)
-        } catch (_: Exception) {
-            null
-        }
-
-    private fun findMethod(
-        clazz: Class<*>,
-        name: String,
-    ) = runCatching { clazz.getMethod(name) }.getOrNull()
-
-    private fun findField(
-        clazz: Class<*>,
-        name: String,
-    ): Field? {
-        var current: Class<*>? = clazz
-        while (true) {
-            val currentClass = current ?: break
-            runCatching { currentClass.getDeclaredField(name) }
-                .getOrNull()
-                ?.let { return it }
-            current = currentClass.superclass
-        }
-        return null
+        JavaScriptExceptionHooks.install(application)
     }
 
     private fun loadNativeLibrary(): Boolean {
@@ -395,11 +265,11 @@ internal class HotUpdaterRecoveryManager(
         shouldRollback: Boolean,
     )
 
-    private class RecoveryJSExceptionHandler(
+    internal class RecoveryJSExceptionHandler(
         private val previousHandler: JSExceptionHandler?,
     ) : JSExceptionHandler {
         override fun handleException(e: Exception) {
-            if (activeManager?.handleJavaScriptException(e) != true) {
+            if (!handleJavaScriptExceptionForRecovery(e)) {
                 previousHandler?.handleException(e) ?: throw e
             }
         }
@@ -432,10 +302,40 @@ internal class HotUpdaterRecoveryManager(
         @Volatile
         private var activeManager: HotUpdaterRecoveryManager? = null
 
-        private val patchedInstanceManagerIds = mutableSetOf<Int>()
-        private val patchedCatalystInstanceIds = mutableSetOf<Int>()
         private val patchedReactContextIds = mutableSetOf<Int>()
-        private val patchedReactHostDelegateIds = mutableSetOf<Int>()
+
+        /** Hands a JavaScript error to the monitored launch; false when it does not recover it. */
+        internal fun handleJavaScriptExceptionForRecovery(exception: Exception): Boolean =
+            activeManager?.handleJavaScriptException(exception) == true
+
+        internal fun patchReactContextExceptionHandler(reactContext: ReactContext) {
+            val contextIdentity = System.identityHashCode(reactContext)
+            if (!patchedReactContextIds.add(contextIdentity)) {
+                return
+            }
+
+            val previousHandler = reactContext.jsExceptionHandler
+            if (previousHandler is RecoveryJSExceptionHandler) {
+                return
+            }
+
+            reactContext.setJSExceptionHandler(RecoveryJSExceptionHandler(previousHandler))
+        }
+
+        internal fun findField(
+            clazz: Class<*>,
+            name: String,
+        ): Field? {
+            var current: Class<*>? = clazz
+            while (true) {
+                val currentClass = current ?: break
+                runCatching { currentClass.getDeclaredField(name) }
+                    .getOrNull()
+                    ?.let { return it }
+                current = currentClass.superclass
+            }
+            return null
+        }
 
         @JvmStatic
         fun handleRecoveryWatchdog(context: Context) {

package/android/src/newarch/JavaScriptExceptionHooks.kt

@@ -0,0 +1,48 @@
+package com.hotupdater
+
+import com.facebook.react.ReactApplication
+
+/**
+ * Routes JavaScript errors of the running React instance to crash recovery.
+ * The New Architecture reaches the instance through ReactHost.
+ */
+internal object JavaScriptExceptionHooks {
+    private val patchedReactHostDelegateIds = mutableSetOf<Int>()
+
+    fun install(application: ReactApplication) {
+        val reactHost = application.reactHost ?: return
+        val reactHostDelegate =
+            HotUpdaterRecoveryManager.findField(reactHost.javaClass, "mReactHostDelegate")?.let { field ->
+                field.isAccessible = true
+                field.get(reactHost)
+            }
+                ?: HotUpdaterRecoveryManager.findField(reactHost.javaClass, "reactHostDelegate")?.let { field ->
+                    field.isAccessible = true
+                    field.get(reactHost)
+                }
+                ?: return
+
+        val delegateIdentity = System.identityHashCode(reactHostDelegate)
+        if (patchedReactHostDelegateIds.add(delegateIdentity)) {
+            val exceptionHandlerField =
+                HotUpdaterRecoveryManager.findField(reactHostDelegate.javaClass, "exceptionHandler")
+            if (exceptionHandlerField == null) {
+                patchedReactHostDelegateIds.remove(delegateIdentity)
+                return
+            }
+
+            exceptionHandlerField.isAccessible = true
+            @Suppress("UNCHECKED_CAST")
+            val previousHandler =
+                exceptionHandlerField.get(reactHostDelegate) as? (Exception) -> Unit
+
+            exceptionHandlerField.set(reactHostDelegate) { exception: Exception ->
+                if (!HotUpdaterRecoveryManager.handleJavaScriptExceptionForRecovery(exception)) {
+                    previousHandler?.invoke(exception) ?: throw exception
+                }
+            }
+        }
+
+        reactHost.currentReactContext?.let(HotUpdaterRecoveryManager::patchReactContextExceptionHandler)
+    }
+}

package/android/src/newarch/ReactIntegrationManager.kt

@@ -5,12 +5,10 @@ import android.util.Log
 import com.facebook.react.ReactApplication
 import com.facebook.react.ReactHost
 import com.facebook.react.ReactInstanceEventListener
-import com.facebook.react.bridge.JSBundleLoader
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.common.LifecycleState
 import kotlinx.coroutines.suspendCancellableCoroutine
-import java.lang.reflect.Field
 import kotlin.coroutines.resume
 
 class ReactIntegrationManager(
@@ -89,7 +87,7 @@ class ReactIntegrationManager(
 
     /**
      * Sets the JS bundle.
-     * Priority: ReactHostHolder (if set) > application.reactHost > reactNativeHost
+     * Priority: ReactHostHolder (if set) > application.reactHost > the bridge (React Native 0.81 and older)
      * @param bundleURL The bundle URL to set
      */
     public fun setJSBundle(bundleURL: String) {
@@ -115,19 +113,8 @@ class ReactIntegrationManager(
                 return
             }
 
-            // 4. Fallback to old architecture (reactNativeHost)
-            @Suppress("DEPRECATION")
-            val instanceManager = application.reactNativeHost.reactInstanceManager
-            val bundleLoader: JSBundleLoader? = this.getJSBundlerLoader(bundleURL)
-            val bundleLoaderField: Field =
-                instanceManager::class.java.getDeclaredField("mBundleLoader")
-            bundleLoaderField.isAccessible = true
-
-            if (bundleLoader != null) {
-                bundleLoaderField.set(instanceManager, bundleLoader)
-            } else {
-                bundleLoaderField.set(instanceManager, null)
-            }
+            // 4. Fall back to the bridge, which React Native 0.81 and older can run
+            BridgeReactInstance.setJSBundle(application, getJSBundlerLoader(bundleURL))
         } catch (e: Exception) {
             Log.d("HotUpdater", "Failed to setJSBundle: ${e.message}")
         }
@@ -135,7 +122,7 @@ class ReactIntegrationManager(
 
     /**
      * Reload the React Native application.
-     * Priority: ReactHostHolder (if set) > application.reactHost > reactNativeHost
+     * Priority: ReactHostHolder (if set) > application.reactHost > the bridge (React Native 0.81 and older)
      */
     public suspend fun reload() {
         try {
@@ -160,21 +147,8 @@ class ReactIntegrationManager(
                 return
             }
 
-            // 4. Fallback to old architecture (reactNativeHost)
-            @Suppress("DEPRECATION")
-            val reactNativeHost = application.reactNativeHost
-            try {
-                reactNativeHost.reactInstanceManager.recreateReactContextInBackground()
-            } catch (e: Exception) {
-                val currentActivity = reactNativeHost.reactInstanceManager.currentReactContext?.currentActivity
-                if (currentActivity == null) {
-                    return
-                }
-
-                currentActivity.runOnUiThread {
-                    currentActivity.recreate()
-                }
-            }
+            // 4. Fall back to the bridge, which React Native 0.81 and older can run
+            BridgeReactInstance.reload(application)
         } catch (e: Exception) {
             Log.d("HotUpdater", "Failed to reload: ${e.message}")
         }

package/android/src/oldarch/JavaScriptExceptionHooks.kt

@@ -0,0 +1,71 @@
+package com.hotupdater
+
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSExceptionHandler
+import com.facebook.react.bridge.ReactContext
+
+/**
+ * Routes JavaScript errors of the running React instance to crash recovery.
+ * The old architecture reaches the instance through ReactNativeHost, which only
+ * an old architecture build compiles.
+ */
+internal object JavaScriptExceptionHooks {
+    private val patchedInstanceManagerIds = mutableSetOf<Int>()
+    private val patchedCatalystInstanceIds = mutableSetOf<Int>()
+
+    fun install(application: ReactApplication) {
+        val instanceManager = application.reactNativeHost.reactInstanceManager
+        val managerIdentity = System.identityHashCode(instanceManager)
+        if (patchedInstanceManagerIds.add(managerIdentity)) {
+            val exceptionHandlerField =
+                HotUpdaterRecoveryManager.findField(instanceManager.javaClass, "mJSExceptionHandler")
+            if (exceptionHandlerField == null) {
+                patchedInstanceManagerIds.remove(managerIdentity)
+                return
+            }
+
+            exceptionHandlerField.isAccessible = true
+            val previousHandler = exceptionHandlerField.get(instanceManager) as? JSExceptionHandler
+            exceptionHandlerField.set(
+                instanceManager,
+                HotUpdaterRecoveryManager.RecoveryJSExceptionHandler(previousHandler),
+            )
+        }
+
+        instanceManager.currentReactContext?.let { reactContext ->
+            HotUpdaterRecoveryManager.patchReactContextExceptionHandler(reactContext)
+            patchCatalystInstanceExceptionHandler(reactContext)
+        }
+    }
+
+    private fun patchCatalystInstanceExceptionHandler(reactContext: ReactContext) {
+        val catalystInstance =
+            try {
+                reactContext.catalystInstance
+            } catch (_: Exception) {
+                null
+            } ?: return
+
+        val catalystIdentity = System.identityHashCode(catalystInstance)
+        if (!patchedCatalystInstanceIds.add(catalystIdentity)) {
+            return
+        }
+
+        val exceptionHandlerField =
+            HotUpdaterRecoveryManager.findField(catalystInstance.javaClass, "mJSExceptionHandler")
+        if (exceptionHandlerField == null) {
+            patchedCatalystInstanceIds.remove(catalystIdentity)
+            return
+        }
+
+        exceptionHandlerField.isAccessible = true
+        val previousHandler = exceptionHandlerField.get(catalystInstance) as? JSExceptionHandler
+        if (previousHandler is HotUpdaterRecoveryManager.RecoveryJSExceptionHandler) {
+            return
+        }
+        exceptionHandlerField.set(
+            catalystInstance,
+            HotUpdaterRecoveryManager.RecoveryJSExceptionHandler(previousHandler),
+        )
+    }
+}

package/ios/HotUpdater/Internal/BundleFileStorageService.swift

@@ -293,6 +293,7 @@ public protocol BundleStorageService {
     func commitReleaseSelection(_ selection: PersistedSelection) -> Bool
 
     // Rollback support
+    func markLaunchStarted(bundleId: String?)
     func markLaunchCompleted(bundleId: String?)
     func notifyAppReady() -> [String: Any]
     func getCrashHistory() -> CrashedHistory
@@ -373,6 +374,13 @@ class BundleFileStorageService: BundleStorageService {
 
     private var hasPreparedLaunch = false
     private var currentLaunchReport: LaunchReport?
+    // The staged bundle this process launched before its first content. Only that
+    // launch is pending; a bundle staged later waits for the next launch.
+    private var pendingLaunchBundleId: String?
+    // Crash history is written at first content on the main thread while JavaScript can read it.
+    private let crashedHistoryLock = NSLock()
+    // A bundle waiting for its retry that this process keeps refusing, see InterruptedLaunch.
+    private var retryHeldBundleId: String?
     private let activeBundleMetadataLock = NSLock()
     private var activeBundleMetadataSnapshot: ActiveBundleMetadataSnapshot?
     private let builtInBundleIdProvider: () -> String
@@ -1308,8 +1316,10 @@ class BundleFileStorageService: BundleStorageService {
         )
     }
 
+    /// Rolls back the pending staging bundle. `unfinishedLaunch` means its launch
+    /// ended before first content without a crash marker.
     @discardableResult
-    private func rollbackPendingBundle(_ stagingId: String) -> Bool {
+    private func rollbackPendingBundle(_ stagingId: String, unfinishedLaunch: Bool = false) -> Bool {
         guard var metadata = loadMetadataOrNull(), metadata.stagingBundleId == stagingId else {
             return false
         }
@@ -1318,9 +1328,7 @@ class BundleFileStorageService: BundleStorageService {
         let pendingSelectionTransition = metadata.pendingSelectionTransition
         let stableSelection = metadata.stableSelection
 
-        var crashedHistory = loadCrashedHistory()
-        crashedHistory.addEntry(stagingId)
-        let _ = saveCrashedHistory(crashedHistory)
+        recordFailedLaunch(stagingId, unfinishedLaunch: unfinishedLaunch)
 
         let fallbackBundleId = metadata.stableBundleId.flatMap { candidate in
             if case .success(let storeDir) = bundleStoreDir() {
@@ -1988,14 +1996,12 @@ class BundleFileStorageService: BundleStorageService {
            metadata.verificationPending,
            metadata.launchInProgress,
            let stagingBundleId = metadata.stagingBundleId {
-            rollbackPendingBundle(stagingBundleId)
+            rollbackPendingBundle(stagingBundleId, unfinishedLaunch: true)
         }
         hasPreparedLaunch = true
+        // A launch is recorded only once it can show UI (markLaunchStarted).
         let selection = selectLaunch(bundle: bundle)
-        if selection.shouldRollbackOnCrash, var metadata = loadMetadataOrNull() {
-            metadata.launchInProgress = true
-            _ = saveMetadata(metadata)
-        }
+        pendingLaunchBundleId = selection.shouldRollbackOnCrash ? selection.launchedBundleId : nil
         return selection
     }
     
@@ -2011,8 +2017,7 @@ class BundleFileStorageService: BundleStorageService {
      */
     func updateBundle(bundleId: String, manifestUrl: URL, manifestFileHash: String, archiveUrl: URL? = nil, assets: [String: ChangedAssetDescriptor], progressHandler: @escaping (UpdateProgressPayload) -> Void, completion: @escaping (Result<UpdateDelivery, Error>) -> Void) {
         // Check if bundle is in crashed history
-        let crashedHistory = loadCrashedHistory()
-        if crashedHistory.contains(bundleId) {
+        if getCrashHistory().contains(bundleId) {
             NSLog("[BundleStorage] Bundle '\(bundleId)' is in crashed history, rejecting update")
             completion(.failure(BundleStorageError.bundleInCrashedHistory(bundleId)))
             return
@@ -2786,7 +2791,24 @@ class BundleFileStorageService: BundleStorageService {
         }
     }
 
+    func markLaunchStarted(bundleId: String?) {
+        // Unlike prepareLaunch, this can run while JavaScript stages a newer bundle.
+        releaseStateLock.lock()
+        defer { releaseStateLock.unlock() }
+        guard let bundleId,
+              var metadata = loadMetadataOrNull(),
+              metadata.verificationPending,
+              !metadata.launchInProgress,
+              metadata.stagingBundleId == bundleId else {
+            return
+        }
+        metadata.launchInProgress = true
+        _ = saveMetadata(metadata)
+    }
+
     func markLaunchCompleted(bundleId: String?) {
+        // Before the guard: content from the built-in bundle (nil) also counts.
+        readyInterruptedLaunchRetry(bundleId)
         guard let bundleId,
               var metadata = loadMetadataOrNull(),
               metadata.verificationPending,
@@ -2818,9 +2840,10 @@ class BundleFileStorageService: BundleStorageService {
 
     func notifyAppReady() -> [String: Any] {
         guard let report = loadLaunchReport() else {
-            if let metadata = loadMetadataOrNull(),
+            if let launchedBundleId = pendingLaunchBundleId,
+               let metadata = loadMetadataOrNull(),
                metadata.verificationPending,
-               metadata.stagingBundleId != nil {
+               metadata.stagingBundleId == launchedBundleId {
                 return ["status": "PENDING"]
             }
             return ["status": LaunchReportStatus.unchanged.rawValue]
@@ -2846,11 +2869,20 @@ class BundleFileStorageService: BundleStorageService {
     }
 
     /**
-     * Returns the crashed bundle history.
+     * Returns the bundles this device refuses to install: crash history, plus a
+     * bundle waiting for its retry until a process that may retry it.
      * @return The crashed history object
      */
     func getCrashHistory() -> CrashedHistory {
-        return loadCrashedHistory()
+        crashedHistoryLock.lock()
+        defer { crashedHistoryLock.unlock() }
+        var history = loadCrashedHistory()
+        if let interrupted = history.interruptedLaunch,
+           !interrupted.retryReady || interrupted.bundleId == retryHeldBundleId,
+           !history.contains(interrupted.bundleId) {
+            history.bundles.append(CrashedBundleEntry(bundleId: interrupted.bundleId))
+        }
+        return history
     }
 
     /**
@@ -2858,11 +2890,57 @@ class BundleFileStorageService: BundleStorageService {
      * @return true if clearing was successful
      */
     func clearCrashHistory() -> Bool {
+        crashedHistoryLock.lock()
+        defer { crashedHistoryLock.unlock() }
         var history = loadCrashedHistory()
         history.clear()
+        retryHeldBundleId = nil
         return saveCrashedHistory(history)
     }
 
+    /// A crash, or a second unfinished launch of the same bundle, adds the bundle
+    /// to crash history. A first unfinished launch cannot tell a hang from a user
+    /// leaving early, so it leaves the bundle one retry instead.
+    private func recordFailedLaunch(_ bundleId: String, unfinishedLaunch: Bool) {
+        crashedHistoryLock.lock()
+        defer { crashedHistoryLock.unlock() }
+        var history = loadCrashedHistory()
+        let interrupted = history.interruptedLaunch
+        if unfinishedLaunch, interrupted?.bundleId != bundleId {
+            NSLog("[BundleStorage] Launch of \(bundleId) ended before first content; it gets one retry")
+            history.interruptedLaunch = InterruptedLaunch(bundleId: bundleId)
+            retryHeldBundleId = bundleId
+        } else {
+            history.addEntry(bundleId)
+            if interrupted?.bundleId == bundleId {
+                history.interruptedLaunch = nil
+            }
+        }
+        _ = saveCrashedHistory(history)
+    }
+
+    /// First content appeared, so the app works again. A bundle waiting for its
+    /// retry may be installed from the next process on. This process keeps
+    /// refusing it, so the session that recovered never reloads into it. Content
+    /// from that bundle verifies it.
+    private func readyInterruptedLaunchRetry(_ currentBundleId: String?) {
+        crashedHistoryLock.lock()
+        defer { crashedHistoryLock.unlock() }
+        var history = loadCrashedHistory()
+        guard let interrupted = history.interruptedLaunch else {
+            return
+        }
+        if interrupted.bundleId == currentBundleId {
+            history.interruptedLaunch = nil
+        } else if interrupted.retryReady {
+            return
+        } else {
+            history.interruptedLaunch?.retryReady = true
+            retryHeldBundleId = interrupted.bundleId
+        }
+        _ = saveCrashedHistory(history)
+    }
+
     func getInstallId() -> String {
         loadOrCreateInstallIdentity().installId
     }

package/ios/HotUpdater/Internal/BundleMetadata.swift

@@ -222,6 +222,37 @@ public struct CrashedBundleEntry: Codable {
     }
 }
 
+// MARK: - InterruptedLaunch
+
+/// A bundle whose launch ended before first content without a crash, waiting
+/// for its one retry. Such a launch cannot tell a hang from a user leaving
+/// early, so the bundle is offered again instead of entering crash history.
+/// A second unfinished launch of it adds it there.
+///
+/// `retryReady` turns true once a later launch shows content. The retry starts
+/// with the next process, so the session that recovered never reloads into the
+/// same bundle.
+public struct InterruptedLaunch: Codable {
+    let bundleId: String
+    var retryReady: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case bundleId
+        case retryReady
+    }
+
+    init(bundleId: String, retryReady: Bool = false) {
+        self.bundleId = bundleId
+        self.retryReady = retryReady
+    }
+
+    public init(from decoder: Decoder) throws {
+        let values = try decoder.container(keyedBy: CodingKeys.self)
+        bundleId = try values.decode(String.self, forKey: .bundleId)
+        retryReady = try values.decodeIfPresent(Bool.self, forKey: .retryReady) ?? false
+    }
+}
+
 // MARK: - CrashedHistory
 
 /// History of crashed bundles
@@ -231,10 +262,30 @@ public struct CrashedHistory: Codable {
 
     var bundles: [CrashedBundleEntry]
     var maxHistorySize: Int
+    var interruptedLaunch: InterruptedLaunch?
+
+    enum CodingKeys: String, CodingKey {
+        case bundles
+        case maxHistorySize
+        case interruptedLaunch
+    }
 
-    init(bundles: [CrashedBundleEntry] = [], maxHistorySize: Int = CrashedHistory.defaultMaxHistorySize) {
+    init(
+        bundles: [CrashedBundleEntry] = [],
+        maxHistorySize: Int = CrashedHistory.defaultMaxHistorySize,
+        interruptedLaunch: InterruptedLaunch? = nil
+    ) {
         self.bundles = bundles
         self.maxHistorySize = maxHistorySize
+        self.interruptedLaunch = interruptedLaunch
+    }
+
+    public init(from decoder: Decoder) throws {
+        let values = try decoder.container(keyedBy: CodingKeys.self)
+        bundles = try values.decode([CrashedBundleEntry].self, forKey: .bundles)
+        maxHistorySize = try values.decode(Int.self, forKey: .maxHistorySize)
+        // A malformed retry record must not drop the crash history.
+        interruptedLaunch = try? values.decodeIfPresent(InterruptedLaunch.self, forKey: .interruptedLaunch)
     }
 
     static func load(from file: URL) -> CrashedHistory {
@@ -298,6 +349,7 @@ public struct CrashedHistory: Codable {
 
     mutating func clear() {
         bundles.removeAll()
+        interruptedLaunch = nil
     }
 }
 

package/ios/HotUpdater/Internal/HotUpdaterImpl.swift

@@ -1,5 +1,6 @@
 import Foundation
 import React
+import UIKit
 
 private func hotUpdaterUncaughtExceptionHandler(_ exception: NSException) {
     HotUpdaterRecoveryManager.shared.handleUncaughtException(exception)
@@ -58,6 +59,7 @@ private func hotUpdaterGetMinBundleId() -> String {
     private let releaseCatalogCache: ReleaseCatalogCacheService
     private let keyValueStorage: KeyValueStorageService
     private var currentLaunchSelection: LaunchSelection?
+    private var launchStartObservers: [NSObjectProtocol] = []
 
     private static let DEFAULT_CHANNEL = "production"
     private static let CHANNEL_STORAGE_KEY = "HotUpdaterChannel"
@@ -703,12 +705,49 @@ private func hotUpdaterGetMinBundleId() -> String {
 
         let pendingRecovery = recoveryManager.consumePendingCrashRecovery()
         let selection = bundleStorage.prepareLaunch(bundle: bundle, pendingRecovery: pendingRecovery)
+        markLaunchStartedInForeground(selection)
         recoveryManager.startMonitoring(bundleId: selection.launchedBundleId, shouldRollback: selection.shouldRollbackOnCrash) { [weak self] launchedBundleId in
             self?.bundleStorage.markLaunchCompleted(bundleId: launchedBundleId)
         }
         currentLaunchSelection = selection
         return selection
     }
+
+    // A background launch, such as a silent push, may never render. Only a
+    // launch in the foreground may leave an unfinished launch for the next
+    // process to roll back.
+    private func markLaunchStartedInForeground(_ selection: LaunchSelection) {
+        let bundleId = selection.shouldRollbackOnCrash ? selection.launchedBundleId : nil
+        let mark = { [weak self] in
+            guard let self else { return }
+            self.removeLaunchStartObservers()
+            guard let bundleId else { return }
+            guard UIApplication.shared.applicationState == .background else {
+                self.bundleStorage.markLaunchStarted(bundleId: bundleId)
+                return
+            }
+            self.launchStartObservers = [
+                UIApplication.willEnterForegroundNotification,
+                UIApplication.didBecomeActiveNotification,
+            ].map { name in
+                NotificationCenter.default.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in
+                    self?.removeLaunchStartObservers()
+                    self?.bundleStorage.markLaunchStarted(bundleId: bundleId)
+                }
+            }
+        }
+        // UIApplication is read on the main thread.
+        if Thread.isMainThread {
+            mark()
+        } else {
+            DispatchQueue.main.async(execute: mark)
+        }
+    }
+
+    private func removeLaunchStartObservers() {
+        launchStartObservers.forEach { NotificationCenter.default.removeObserver($0) }
+        launchStartObservers = []
+    }
 }
 
 @objcMembers

package/lib/commonjs/sdkVersion.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.HOT_UPDATER_SDK_VERSION = void 0;
-const HOT_UPDATER_SDK_VERSION = exports.HOT_UPDATER_SDK_VERSION = "1.0.0-rc.34";
+const HOT_UPDATER_SDK_VERSION = exports.HOT_UPDATER_SDK_VERSION = "1.0.0-rc.35";
 //# sourceMappingURL=sdkVersion.js.map

package/lib/module/sdkVersion.js

@@ -1,4 +1,4 @@
 "use strict";
 
-export const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.34";
+export const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.35";
 //# sourceMappingURL=sdkVersion.js.map

package/lib/typescript/commonjs/sdkVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.34";
+export declare const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.35";
 //# sourceMappingURL=sdkVersion.d.ts.map

package/lib/typescript/module/sdkVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.34";
+export declare const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.35";
 //# sourceMappingURL=sdkVersion.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "1.0.0-rc.34",
+  "version": "1.0.0-rc.35",
   "description": "React Native OTA solution for self-hosted",
   "source": "./src/index.ts",
   "main": "./lib/commonjs/index.js",
@@ -123,8 +123,8 @@
   },
   "dependencies": {
     "use-sync-external-store": "1.5.0",
-    "@hot-updater/protocol": "1.0.0-rc.30",
-    "@hot-updater/plugin-insights": "1.0.0-rc.34"
+    "@hot-updater/protocol": "1.0.0-rc.35",
+    "@hot-updater/plugin-insights": "1.0.0-rc.35"
   },
   "scripts": {
     "build": "node ./scripts/sync-sdk-version.mjs run -- bob build",

package/src/sdkVersion.ts

@@ -1 +1 @@
-export const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.34";
+export const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.35";