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

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
     }
 }