@hot-updater/react-native 0.27.0 → 0.28.0

package/android/src/oldarch/HotUpdaterModule.kt

@@ -153,17 +153,11 @@ class HotUpdaterModule internal constructor(
     }
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun notifyAppReady(params: ReadableMap): String {
-        val bundleId = params.getString("bundleId")
+    override fun notifyAppReady(): String {
         val result = JSONObject()
 
-        if (bundleId == null) {
-            result.put("status", "STABLE")
-            return result.toString()
-        }
-
         val impl = getInstance()
-        val statusMap = impl.notifyAppReady(bundleId)
+        val statusMap = impl.notifyAppReady()
 
         result.put("status", statusMap["status"] as? String ?: "STABLE")
         statusMap["crashedBundleId"]?.let {

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -17,7 +17,7 @@ abstract class HotUpdaterSpec internal constructor(
 
     abstract fun reloadProcess(promise: Promise)
 
-    abstract fun notifyAppReady(params: ReadableMap): String
+    abstract fun notifyAppReady(): String
 
     abstract fun getCrashHistory(): String
 

package/ios/HotUpdater/Internal/BundleFileStorageService.swift

@@ -103,13 +103,14 @@ public protocol BundleStorageService {
     func setBundleURL(localPath: String?) -> Result<Void, Error>
     func getCachedBundleURL() -> URL?
     func getFallbackBundleURL(bundle: Bundle) -> URL? // Synchronous as it's lightweight
-    func getBundleURL(bundle: Bundle) -> URL?
+    func prepareLaunch(bundle: Bundle, pendingRecovery: PendingCrashRecovery?) -> LaunchSelection
 
     // Bundle update
     func updateBundle(bundleId: String, fileUrl: URL?, fileHash: String?, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<Bool, Error>) -> Void)
 
     // Rollback support
-    func notifyAppReady(bundleId: String) -> [String: Any]
+    func markLaunchCompleted(bundleId: String?)
+    func notifyAppReady() -> [String: Any]
     func getCrashHistory() -> CrashedHistory
     func clearCrashHistory() -> Bool
     
@@ -139,8 +140,7 @@ class BundleFileStorageService: BundleStorageService {
 
     private var activeTasks: [URLSessionTask] = []
 
-    // Session-only rollback tracking (in-memory)
-    private var sessionRollbackBundleId: String?
+    private var currentLaunchReport: LaunchReport?
 
     public init(fileSystem: FileSystemService,
                 downloadService: DownloadService,
@@ -182,6 +182,13 @@ class BundleFileStorageService: BundleStorageService {
         return URL(fileURLWithPath: storeDir).appendingPathComponent(CrashedHistory.crashedHistoryFilename)
     }
 
+    private func launchReportFileURL() -> URL? {
+        guard case .success(let storeDir) = bundleStoreDir() else {
+            return nil
+        }
+        return URL(fileURLWithPath: storeDir).appendingPathComponent(LaunchReport.launchReportFilename)
+    }
+
     // MARK: - Metadata Operations
 
     private func loadMetadataOrNull() -> BundleMetadata? {
@@ -200,6 +207,51 @@ class BundleFileStorageService: BundleStorageService {
         return updatedMetadata.save(to: file)
     }
 
+    private func loadLaunchReport() -> LaunchReport? {
+        if let currentLaunchReport {
+            return currentLaunchReport
+        }
+        guard let file = launchReportFileURL(),
+              let report = LaunchReport.load(from: file) else {
+            return nil
+        }
+        currentLaunchReport = report
+        return report
+    }
+
+    private func saveLaunchReport(_ report: LaunchReport?) {
+        currentLaunchReport = report
+        guard let file = launchReportFileURL() else {
+            return
+        }
+
+        guard let report else {
+            if FileManager.default.fileExists(atPath: file.path) {
+                try? FileManager.default.removeItem(at: file)
+            }
+            return
+        }
+
+        _ = report.save(to: file)
+    }
+
+    private func createInitialMetadata() -> BundleMetadata {
+        let currentBundleId = getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent
+        return BundleMetadata(
+            isolationKey: isolationKey,
+            stableBundleId: nil,
+            stagingBundleId: currentBundleId,
+            verificationPending: false
+        )
+    }
+
+    private func getCurrentVerifiedBundleId(_ metadata: BundleMetadata) -> String? {
+        if let stagingBundleId = metadata.stagingBundleId, !metadata.verificationPending {
+            return stagingBundleId
+        }
+        return metadata.stableBundleId
+    }
+
     /**
      * Checks if isolationKey has changed and cleans up old bundles if needed.
      * This handles migration when isolationKey format changes.
@@ -289,100 +341,78 @@ class BundleFileStorageService: BundleStorageService {
         return metadata.verificationPending && metadata.stagingBundleId != nil
     }
 
-    private func wasVerificationAttempted(_ metadata: BundleMetadata) -> Bool {
-        return metadata.verificationAttemptedAt != nil
+    private func prepareMetadataForNewStagingBundle(_ metadata: BundleMetadata, bundleId: String) -> BundleMetadata {
+        let currentVerifiedBundleId = getCurrentVerifiedBundleId(metadata).flatMap { $0 == bundleId ? nil : $0 }
+        return BundleMetadata(
+            isolationKey: isolationKey,
+            stableBundleId: currentVerifiedBundleId,
+            stagingBundleId: bundleId,
+            verificationPending: true,
+            updatedAt: Date().timeIntervalSince1970 * 1000
+        )
     }
 
-    private func markVerificationAttempted() {
-        guard var metadata = loadMetadataOrNull() else {
-            return
+    @discardableResult
+    private func rollbackPendingBundle(_ stagingId: String) -> Bool {
+        guard var metadata = loadMetadataOrNull(), metadata.stagingBundleId == stagingId else {
+            return false
         }
-        metadata.verificationAttemptedAt = Date().timeIntervalSince1970 * 1000
-        let _ = saveMetadata(metadata)
-        NSLog("[BundleStorage] Marked verification attempted for staging bundle: \(metadata.stagingBundleId ?? "nil")")
-    }
 
-    private func incrementStagingExecutionCount() {
-        guard var metadata = loadMetadataOrNull() else {
-            return
-        }
-        metadata.stagingExecutionCount = (metadata.stagingExecutionCount ?? 0) + 1
-        metadata.updatedAt = Date().timeIntervalSince1970 * 1000
-        let _ = saveMetadata(metadata)
-        NSLog("[BundleStorage] Incremented staging execution count to: \(metadata.stagingExecutionCount ?? 0)")
-    }
+        var crashedHistory = loadCrashedHistory()
+        crashedHistory.addEntry(stagingId)
+        let _ = saveCrashedHistory(crashedHistory)
 
-    private func promoteStagingToStable() {
-        guard var metadata = loadMetadataOrNull() else {
-            return
-        }
-        guard let stagingId = metadata.stagingBundleId else {
-            NSLog("[BundleStorage] No staging bundle to promote")
-            return
+        let fallbackBundleId = metadata.stableBundleId.flatMap { candidate in
+            if case .success(let storeDir) = bundleStoreDir() {
+                let stableBundleDir = (storeDir as NSString).appendingPathComponent(candidate)
+                if case .success(let bundlePath) = findBundleFile(in: stableBundleDir), bundlePath != nil {
+                    return candidate
+                }
+            }
+            return nil
         }
 
-        let oldStableId = metadata.stableBundleId
-        metadata.stableBundleId = stagingId
-        metadata.stagingBundleId = nil
-        metadata.verificationPending = false
-        metadata.verificationAttemptedAt = nil
-        metadata.stagingExecutionCount = nil
-        metadata.updatedAt = Date().timeIntervalSince1970 * 1000
+        metadata = BundleMetadata(
+            isolationKey: isolationKey,
+            stableBundleId: nil,
+            stagingBundleId: fallbackBundleId,
+            verificationPending: false,
+            updatedAt: Date().timeIntervalSince1970 * 1000
+        )
 
-        if saveMetadata(metadata) {
-            NSLog("[BundleStorage] Promoted staging '\(stagingId)' to stable (old stable: \(oldStableId ?? "nil"))")
+        guard saveMetadata(metadata) else {
+            return false
+        }
 
-            // Clean up old stable bundle
-            if let oldId = oldStableId, oldId != stagingId {
-                let _ = cleanupOldBundles(currentBundleId: stagingId, bundleId: nil)
+        if let fallbackBundleId,
+           case .success(let storeDir) = bundleStoreDir() {
+            let fallbackBundleDir = (storeDir as NSString).appendingPathComponent(fallbackBundleId)
+            if case .success(let bundlePath) = findBundleFile(in: fallbackBundleDir), let bundlePath {
+                let _ = setBundleURL(localPath: bundlePath)
             }
+        } else {
+            let _ = setBundleURL(localPath: nil)
         }
-    }
 
-    private func rollbackToStable() {
-        guard var metadata = loadMetadataOrNull() else {
-            return
-        }
-        guard let stagingId = metadata.stagingBundleId else {
-            NSLog("[BundleStorage] No staging bundle to rollback from")
-            return
+        if case .success(let storeDir) = bundleStoreDir() {
+            let stagingDir = (storeDir as NSString).appendingPathComponent(stagingId)
+            try? fileSystem.removeItem(atPath: stagingDir)
         }
 
-        // Add crashed bundle to history
-        var crashedHistory = loadCrashedHistory()
-        crashedHistory.addEntry(stagingId)
-        let _ = saveCrashedHistory(crashedHistory)
-        NSLog("[BundleStorage('\(id)')] Added bundle '\(stagingId)' to crashed history")
-
-        // Save rollback info to session variable (memory only)
-        self.sessionRollbackBundleId = stagingId
-
-        // Clear staging
-        metadata.stagingBundleId = nil
-        metadata.verificationPending = false
-        metadata.verificationAttemptedAt = nil
-        metadata.stagingExecutionCount = nil
-        metadata.updatedAt = Date().timeIntervalSince1970 * 1000
-
-        if saveMetadata(metadata) {
-            NSLog("[BundleStorage] Rolled back to stable bundle: \(metadata.stableBundleId ?? "fallback")")
-
-            // Update HotUpdaterBundleURL to point to stable bundle
-            if let stableId = metadata.stableBundleId {
-                if case .success(let storeDir) = bundleStoreDir() {
-                    let stableBundleDir = (storeDir as NSString).appendingPathComponent(stableId)
-                    if case .success(let bundlePath) = findBundleFile(in: stableBundleDir), let path = bundlePath {
-                        let _ = setBundleURL(localPath: path)
-                    }
-                }
-            } else {
-                // Reset to fallback
-                let _ = setBundleURL(localPath: nil)
-            }
+        saveLaunchReport(LaunchReport(status: "RECOVERED", crashedBundleId: stagingId))
+        return true
+    }
 
-            // Clean up failed staging bundle
-            let _ = cleanupOldBundles(currentBundleId: metadata.stableBundleId, bundleId: nil)
+    private func applyPendingRecoveryIfNeeded(_ pendingRecovery: PendingCrashRecovery?) {
+        guard let metadata = loadMetadataOrNull(),
+              let stagingBundleId = metadata.stagingBundleId,
+              pendingRecovery?.shouldRollback == true,
+              pendingRecovery?.launchedBundleId == stagingBundleId,
+              isVerificationPending(metadata) else {
+            return
         }
+
+        _ = rollbackPendingBundle(stagingBundleId)
     }
     
     // MARK: - Directory Management
@@ -599,66 +629,55 @@ class BundleFileStorageService: BundleStorageService {
     func getFallbackBundleURL(bundle: Bundle) -> URL? {
         return bundle.url(forResource: "main", withExtension: "jsbundle")
     }
-    
-    public func getBundleURL(bundle: Bundle) -> URL? {
-        // Try to load metadata
-        let metadata = loadMetadataOrNull()
-
-        // If no metadata exists, use legacy behavior (backwards compatible)
-        guard let metadata = metadata else {
-            let cached = getCachedBundleURL()
-            return cached ?? getFallbackBundleURL(bundle: bundle)
-        }
 
-        // Check if we need to handle crash recovery
-        if isVerificationPending(metadata) {
-            let executionCount = metadata.stagingExecutionCount ?? 0
-
-            if executionCount == 0 {
-                // First execution - give staging bundle a chance
-                NSLog("[BundleStorage] First execution of staging bundle, incrementing counter")
-                incrementStagingExecutionCount()
-                // Don't mark verificationAttempted yet!
-            } else if wasVerificationAttempted(metadata) {
-                // Already executed once and verificationAttempted is set → crash!
-                NSLog("[BundleStorage] Crash detected: staging bundle executed but didn't call notifyAppReady")
-                rollbackToStable()
-            } else {
-                // Second execution - now mark verification attempted
-                NSLog("[BundleStorage] Second execution of staging bundle, marking verification attempted")
-                markVerificationAttempted()
-            }
+    private func selectLaunch(bundle: Bundle) -> LaunchSelection {
+        guard let metadata = loadMetadataOrNull() else {
+            return LaunchSelection(
+                bundleURL: getCachedBundleURL() ?? getFallbackBundleURL(bundle: bundle),
+                launchedBundleId: getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent,
+                shouldRollbackOnCrash: false
+            )
         }
 
-        // Reload metadata after potential rollback
-        guard let currentMetadata = loadMetadataOrNull() else {
-            return getCachedBundleURL() ?? getFallbackBundleURL(bundle: bundle)
-        }
+        if let stagingId = metadata.stagingBundleId,
+           case .success(let storeDir) = bundleStoreDir() {
+            let stagingBundleDir = (storeDir as NSString).appendingPathComponent(stagingId)
+            if case .success(let bundlePath) = findBundleFile(in: stagingBundleDir), let bundlePath {
+                return LaunchSelection(
+                    bundleURL: URL(fileURLWithPath: bundlePath),
+                    launchedBundleId: stagingId,
+                    shouldRollbackOnCrash: metadata.verificationPending
+                )
+            }
 
-        // If verification is pending, return staging bundle URL
-        if isVerificationPending(currentMetadata), let stagingId = currentMetadata.stagingBundleId {
-            if case .success(let storeDir) = bundleStoreDir() {
-                let stagingBundleDir = (storeDir as NSString).appendingPathComponent(stagingId)
-                if case .success(let bundlePath) = findBundleFile(in: stagingBundleDir), let path = bundlePath {
-                    NSLog("[BundleStorage] Returning staging bundle URL: \(path)")
-                    return URL(fileURLWithPath: path)
-                }
+            if metadata.verificationPending, rollbackPendingBundle(stagingId) {
+                return selectLaunch(bundle: bundle)
             }
         }
 
-        // Return stable bundle URL
-        if let stableId = currentMetadata.stableBundleId {
-            if case .success(let storeDir) = bundleStoreDir() {
-                let stableBundleDir = (storeDir as NSString).appendingPathComponent(stableId)
-                if case .success(let bundlePath) = findBundleFile(in: stableBundleDir), let path = bundlePath {
-                    NSLog("[BundleStorage] Returning stable bundle URL: \(path)")
-                    return URL(fileURLWithPath: path)
-                }
+        if let stableId = metadata.stableBundleId,
+           case .success(let storeDir) = bundleStoreDir() {
+            let stableBundleDir = (storeDir as NSString).appendingPathComponent(stableId)
+            if case .success(let bundlePath) = findBundleFile(in: stableBundleDir), let bundlePath {
+                return LaunchSelection(
+                    bundleURL: URL(fileURLWithPath: bundlePath),
+                    launchedBundleId: stableId,
+                    shouldRollbackOnCrash: false
+                )
             }
         }
 
-        // Fallback to app bundle
-        return getFallbackBundleURL(bundle: bundle)
+        return LaunchSelection(
+            bundleURL: getFallbackBundleURL(bundle: bundle),
+            launchedBundleId: getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent,
+            shouldRollbackOnCrash: false
+        )
+    }
+
+    func prepareLaunch(bundle: Bundle, pendingRecovery: PendingCrashRecovery?) -> LaunchSelection {
+        saveLaunchReport(nil)
+        applyPendingRecoveryIfNeeded(pendingRecovery)
+        return selectLaunch(bundle: bundle)
     }
     
     // MARK: - Bundle Update
@@ -691,6 +710,8 @@ class BundleFileStorageService: BundleStorageService {
                 let setResult = self.setBundleURL(localPath: nil)
                 switch setResult {
                 case .success:
+                    let _ = self.saveMetadata(self.createInitialMetadata())
+                    self.saveLaunchReport(nil)
                     let cleanupResult = self.cleanupOldBundles(currentBundleId: currentBundleId, bundleId: bundleId)
                     switch cleanupResult {
                     case .success:
@@ -727,19 +748,13 @@ class BundleFileStorageService: BundleStorageService {
                         let setResult = self.setBundleURL(localPath: bundlePath)
                         switch setResult {
                         case .success:
-                            // Set staging metadata for rollback support
-                            var metadata = self.loadMetadataOrNull() ?? BundleMetadata()
-                            metadata.stagingBundleId = bundleId
-                            metadata.verificationPending = true
-                            metadata.verificationAttemptedAt = nil
-                            metadata.stagingExecutionCount = 0
-                            metadata.updatedAt = Date().timeIntervalSince1970 * 1000
-                            let _ = self.saveMetadata(metadata)
+                            let currentMetadata = self.loadMetadataOrNull() ?? self.createInitialMetadata()
+                            let updatedMetadata = self.prepareMetadataForNewStagingBundle(currentMetadata, bundleId: bundleId)
+                            let _ = self.saveMetadata(updatedMetadata)
                             NSLog("[BundleStorage] Set staging bundle (cached): \(bundleId), verificationPending: true")
 
-                            // Clean up old bundles, preserving stable and new staging
-                            let stableId = metadata.stableBundleId
-                            let bundleIdsToKeep = [stableId, bundleId].compactMap { $0 }
+                            // Clean up old bundles, preserving the fallback and new staging bundle.
+                            let bundleIdsToKeep = [updatedMetadata.stableBundleId, bundleId].compactMap { $0 }
                             if bundleIdsToKeep.count > 0 {
                                 let _ = self.cleanupOldBundles(currentBundleId: bundleIdsToKeep.first, bundleId: bundleIdsToKeep.count > 1 ? bundleIdsToKeep[1] : nil)
                             }
@@ -1045,21 +1060,16 @@ class BundleFileStorageService: BundleStorageService {
                         NSLog("[BundleStorage] Successfully set bundle URL: \(finalBundlePath)")
 
                         // 13) Set staging metadata for rollback support
-                        var metadata = self.loadMetadataOrNull() ?? BundleMetadata()
-                        metadata.stagingBundleId = bundleId
-                        metadata.verificationPending = true
-                        metadata.verificationAttemptedAt = nil
-                        metadata.stagingExecutionCount = 0
-                        metadata.updatedAt = Date().timeIntervalSince1970 * 1000
-                        let _ = self.saveMetadata(metadata)
+                        let currentMetadata = self.loadMetadataOrNull() ?? self.createInitialMetadata()
+                        let updatedMetadata = self.prepareMetadataForNewStagingBundle(currentMetadata, bundleId: bundleId)
+                        let _ = self.saveMetadata(updatedMetadata)
                         NSLog("[BundleStorage] Set staging bundle: \(bundleId), verificationPending: true")
 
                         // 14) Clean up the temporary directory
                         self.cleanupTemporaryFiles([tempDirectory])
 
-                        // 15) Clean up old bundles, preserving current, stable, and new staging
-                        let stableId = metadata.stableBundleId
-                        let bundleIdsToKeep = [stableId, bundleId].compactMap { $0 }
+                        // 15) Clean up old bundles, preserving the fallback and new staging bundle.
+                        let bundleIdsToKeep = [updatedMetadata.stableBundleId, bundleId].compactMap { $0 }
                         if bundleIdsToKeep.count > 0 {
                             let _ = self.cleanupOldBundles(currentBundleId: bundleIdsToKeep.first, bundleId: bundleIdsToKeep.count > 1 ? bundleIdsToKeep[1] : nil)
                         }
@@ -1110,57 +1120,31 @@ class BundleFileStorageService: BundleStorageService {
     // MARK: - Rollback Support
 
     /**
-     * Notifies the system that the app has successfully started with the given bundle.
-     * If the bundle matches the staging bundle, promotes it to stable.
-     * @param bundleId The ID of the currently running bundle
-     * @return true if promotion was successful or no action was needed
+     * Marks the current launch as successful after the first content appeared.
      */
-    func notifyAppReady(bundleId: String) -> [String: Any] {
-        NSLog("[BundleStorage('\(id)'] notifyAppReady: Called with bundleId '\(bundleId)'")
-        guard var metadata = loadMetadataOrNull() else {
-            // No metadata exists - legacy mode, nothing to do
-            NSLog("[BundleStorage] notifyAppReady: No metadata exists (legacy mode)")
-            return ["status": "STABLE"]
-        }
-
-        // Check if there was a recent rollback (session variable)
-        if let crashedBundleId = self.sessionRollbackBundleId {
-            NSLog("[BundleStorage] notifyAppReady: Detected rollback recovery from '\(crashedBundleId)'")
-
-            // Clear rollback info (one-time read)
-            self.sessionRollbackBundleId = nil
-
-            return [
-                "status": "RECOVERED",
-                "crashedBundleId": crashedBundleId
-            ]
+    func markLaunchCompleted(bundleId: String?) {
+        guard let bundleId,
+              var metadata = loadMetadataOrNull(),
+              metadata.verificationPending,
+              metadata.stagingBundleId == bundleId else {
+            return
         }
 
-        // Check if the bundle matches the staging bundle (promotion case)
-        if let stagingId = metadata.stagingBundleId, stagingId == bundleId, metadata.verificationPending {
-            NSLog("[BundleStorage] notifyAppReady: Bundle '\(bundleId)' matches staging, promoting to stable")
-            promoteStagingToStable()
-            return ["status": "PROMOTED"]
-        }
+        metadata.verificationPending = false
+        metadata.updatedAt = Date().timeIntervalSince1970 * 1000
+        let _ = saveMetadata(metadata)
+    }
 
-        // Check if the bundle matches the stable bundle
-        if let stableId = metadata.stableBundleId, stableId == bundleId {
-            // Already stable, clear any pending verification state
-            if metadata.verificationPending {
-                metadata.verificationPending = false
-                metadata.verificationAttemptedAt = nil
-                metadata.updatedAt = Date().timeIntervalSince1970 * 1000
-                let _ = saveMetadata(metadata)
-                NSLog("[BundleStorage] notifyAppReady: Bundle '\(bundleId)' is stable, cleared pending verification")
-            } else {
-                NSLog("[BundleStorage] notifyAppReady: Bundle '\(bundleId)' is already stable")
-            }
+    func notifyAppReady() -> [String: Any] {
+        guard let report = loadLaunchReport() else {
             return ["status": "STABLE"]
         }
 
-        // Bundle doesn't match staging or stable - might be fallback or unknown
-        NSLog("[BundleStorage] notifyAppReady: Bundle '\(bundleId)' doesn't match staging or stable")
-        return ["status": "STABLE"]
+        var result: [String: Any] = ["status": report.status]
+        if let crashedBundleId = report.crashedBundleId {
+            result["crashedBundleId"] = crashedBundleId
+        }
+        return result
     }
 
     /**
@@ -1190,8 +1174,8 @@ class BundleFileStorageService: BundleStorageService {
             let metadata = loadMetadataOrNull()
             let activeBundleId: String?
 
-            // Prefer staging bundle if verification is pending
-            if let meta = metadata, meta.verificationPending, let staging = meta.stagingBundleId {
+            // Prefer the current staging bundle regardless of verification state.
+            if let staging = metadata?.stagingBundleId {
                 activeBundleId = staging
             } else if let stable = metadata?.stableBundleId {
                 activeBundleId = stable
@@ -1240,22 +1224,24 @@ class BundleFileStorageService: BundleStorageService {
             isolationKey: isolationKey,
             stableBundleId: nil,
             stagingBundleId: nil,
-            verificationPending: false,
-            verificationAttemptedAt: nil,
-            stagingExecutionCount: nil
+            verificationPending: false
         )
 
         guard saveMetadata(clearedMetadata) else {
             return .failure(BundleStorageError.unknown(nil))
         }
 
+        saveLaunchReport(nil)
+
         guard case .success(let storeDir) = bundleStoreDir() else {
             return .failure(BundleStorageError.unknown(nil))
         }
 
         do {
             for item in try fileSystem.contentsOfDirectory(atPath: storeDir) {
-                if item == BundleMetadata.metadataFilename || item == CrashedHistory.crashedHistoryFilename {
+                if item == BundleMetadata.metadataFilename ||
+                    item == CrashedHistory.crashedHistoryFilename ||
+                    item == LaunchReport.launchReportFilename {
                     continue
                 }
 

package/ios/HotUpdater/Internal/BundleMetadata.swift

@@ -12,8 +12,6 @@ public struct BundleMetadata: Codable {
     var stableBundleId: String?
     var stagingBundleId: String?
     var verificationPending: Bool
-    var verificationAttemptedAt: Double?
-    var stagingExecutionCount: Int?
     var updatedAt: Double
 
     enum CodingKeys: String, CodingKey {
@@ -22,8 +20,6 @@ public struct BundleMetadata: Codable {
         case stableBundleId = "stable_bundle_id"
         case stagingBundleId = "staging_bundle_id"
         case verificationPending = "verification_pending"
-        case verificationAttemptedAt = "verification_attempted_at"
-        case stagingExecutionCount = "staging_execution_count"
         case updatedAt = "updated_at"
     }
 
@@ -33,8 +29,6 @@ public struct BundleMetadata: Codable {
         stableBundleId: String? = nil,
         stagingBundleId: String? = nil,
         verificationPending: Bool = false,
-        verificationAttemptedAt: Double? = nil,
-        stagingExecutionCount: Int? = nil,
         updatedAt: Double = Date().timeIntervalSince1970 * 1000
     ) {
         self.schema = schema
@@ -42,8 +36,6 @@ public struct BundleMetadata: Codable {
         self.stableBundleId = stableBundleId
         self.stagingBundleId = stagingBundleId
         self.verificationPending = verificationPending
-        self.verificationAttemptedAt = verificationAttemptedAt
-        self.stagingExecutionCount = stagingExecutionCount
         self.updatedAt = updatedAt
     }
 
@@ -191,3 +183,64 @@ public struct CrashedHistory: Codable {
         bundles.removeAll()
     }
 }
+
+public struct PendingCrashRecovery {
+    let launchedBundleId: String?
+    let shouldRollback: Bool
+
+    static func from(json: [String: Any]) -> PendingCrashRecovery {
+        PendingCrashRecovery(
+            launchedBundleId: (json["bundleId"] as? String).flatMap { $0.isEmpty ? nil : $0 },
+            shouldRollback: json["shouldRollback"] as? Bool ?? false
+        )
+    }
+}
+
+public struct LaunchSelection {
+    let bundleURL: URL?
+    let launchedBundleId: String?
+    let shouldRollbackOnCrash: Bool
+}
+
+public struct LaunchReport: Codable {
+    static let launchReportFilename = "launch-report.json"
+
+    let status: String
+    let crashedBundleId: String?
+
+    init(status: String = "STABLE", crashedBundleId: String? = nil) {
+        self.status = status
+        self.crashedBundleId = crashedBundleId
+    }
+
+    static func load(from file: URL) -> LaunchReport? {
+        guard FileManager.default.fileExists(atPath: file.path) else {
+            return nil
+        }
+
+        do {
+            let data = try Data(contentsOf: file)
+            return try JSONDecoder().decode(LaunchReport.self, from: data)
+        } catch {
+            print("[LaunchReport] Failed to load launch report: \(error)")
+            return nil
+        }
+    }
+
+    func save(to file: URL) -> Bool {
+        do {
+            let encoder = JSONEncoder()
+            encoder.outputFormatting = .prettyPrinted
+            let data = try encoder.encode(self)
+            let directory = file.deletingLastPathComponent()
+            if !FileManager.default.fileExists(atPath: directory.path) {
+                try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+            }
+            try data.write(to: file)
+            return true
+        } catch {
+            print("[LaunchReport] Failed to save launch report: \(error)")
+            return false
+        }
+    }
+}