@hot-updater/react-native 0.27.1 → 0.29.0

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

@@ -4,6 +4,7 @@ import android.os.StatFs
 import android.util.Log
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import org.json.JSONObject
 import java.io.File
 import java.net.URL
 
@@ -31,11 +32,11 @@ interface BundleStorageService {
     fun getFallbackBundleURL(): String
 
     /**
-     * Gets the URL to the bundle file (cached or fallback)
-     * With rollback support: checks for crashed staging bundles
-     * @return The path to the bundle file
+     * Prepares the bundle launch for the current process.
+     * Applies any pending rollback decision from the previous launch and returns
+     * the bundle that should be loaded now.
      */
-    fun getBundleURL(): String
+    fun prepareLaunch(pendingRecovery: PendingCrashRecovery?): LaunchSelection
 
     /**
      * Updates the bundle from the specified URL
@@ -53,11 +54,14 @@ interface BundleStorageService {
     )
 
     /**
-     * Notifies that the app has started successfully with the current bundle
-     * @param currentBundleId The bundle ID that JS reports as currently loaded
-     * @return Map containing status and optional crashedBundleId
+     * Marks the current launch as successful after the first content appeared.
      */
-    fun notifyAppReady(currentBundleId: String?): Map<String, Any?>
+    fun markLaunchCompleted(currentBundleId: String?)
+
+    /**
+     * Returns the launch report for the current process.
+     */
+    fun notifyAppReady(): Map<String, Any?>
 
     /**
      * Gets the crashed bundle history
@@ -77,6 +81,18 @@ interface BundleStorageService {
      */
     fun getBaseURL(): String
 
+    /**
+     * Gets the current active bundle ID from bundle storage.
+     * Reads manifest.json first and falls back to older metadata when needed.
+     */
+    fun getBundleId(): String?
+
+    /**
+     * Gets the current manifest from bundle storage.
+     * Returns an empty map when manifest.json is missing or invalid.
+     */
+    fun getManifest(): Map<String, Any?>
+
     /**
      * Restores the original bundle and clears downloaded bundle state.
      * @return true if the reset was successful
@@ -99,6 +115,12 @@ class BundleFileStorageService(
         private const val TAG = "BundleStorage"
     }
 
+    private data class ActiveBundleMetadataSnapshot(
+        val activeBundleId: String,
+        val bundleId: String?,
+        val manifest: Map<String, Any?>,
+    )
+
     init {
         // Ensure bundle store directory exists
         getBundleStoreDir().mkdirs()
@@ -107,8 +129,11 @@ class BundleFileStorageService(
         checkAndCleanupIfIsolationKeyChanged()
     }
 
-    // Session-only rollback tracking (in-memory)
-    private var sessionRollbackBundleId: String? = null
+    private var currentLaunchReport: LaunchReport? = null
+
+    @Volatile
+    private var activeBundleMetadataSnapshot: ActiveBundleMetadataSnapshot? = null
+    private val activeBundleMetadataLock = Any()
 
     // MARK: - Bundle Store Directory
 
@@ -121,6 +146,8 @@ class BundleFileStorageService(
 
     private fun getCrashedHistoryFile(): File = File(getBundleStoreDir(), CrashedHistory.CRASHED_HISTORY_FILENAME)
 
+    private fun getLaunchReportFile(): File = File(getBundleStoreDir(), LaunchReport.LAUNCH_REPORT_FILENAME)
+
     // MARK: - Metadata Operations
 
     private fun loadMetadataOrNull(): BundleMetadata? = BundleMetadata.loadFromFile(getMetadataFile(), isolationKey)
@@ -130,14 +157,30 @@ class BundleFileStorageService(
         return updatedMetadata.saveToFile(getMetadataFile())
     }
 
+    private fun loadLaunchReport(): LaunchReport? =
+        currentLaunchReport ?: LaunchReport.loadFromFile(getLaunchReportFile())?.also {
+            currentLaunchReport = it
+        }
+
+    private fun saveLaunchReport(report: LaunchReport?) {
+        currentLaunchReport = report
+        val file = getLaunchReportFile()
+        if (report == null) {
+            if (file.exists()) {
+                file.delete()
+            }
+            return
+        }
+        report.saveToFile(file)
+    }
+
     private fun createInitialMetadata(): BundleMetadata {
         val currentBundleId = extractBundleIdFromCurrentURL()
-        Log.d(TAG, "Creating initial metadata with stableBundleId: $currentBundleId")
+        Log.d(TAG, "Creating initial metadata with stagingBundleId: $currentBundleId")
         return BundleMetadata(
-            stableBundleId = currentBundleId,
-            stagingBundleId = null,
+            stableBundleId = null,
+            stagingBundleId = currentBundleId,
             verificationPending = false,
-            verificationAttemptedAt = null,
         )
     }
 
@@ -148,6 +191,135 @@ class BundleFileStorageService(
         return regex.find(currentUrl)?.groupValues?.get(1)
     }
 
+    private fun findBundleFile(bundleId: String): File? {
+        val bundleDir = File(getBundleStoreDir(), bundleId)
+        return bundleDir.walk().find { it.name == "index.android.bundle" && it.exists() }
+    }
+
+    private fun getBundleUrlForId(bundleId: String): String? = findBundleFile(bundleId)?.absolutePath
+
+    private fun getCurrentVerifiedBundleId(metadata: BundleMetadata): String? =
+        when {
+            metadata.stagingBundleId != null && !metadata.verificationPending -> metadata.stagingBundleId
+            metadata.stableBundleId != null -> metadata.stableBundleId
+            else -> null
+        }
+
+    private fun getActiveBundleId(): String? {
+        val metadata = loadMetadataOrNull()
+        return when {
+            metadata?.stagingBundleId != null -> metadata.stagingBundleId
+            metadata?.stableBundleId != null -> metadata.stableBundleId
+            else -> extractBundleIdFromCurrentURL()
+        }
+    }
+
+    private fun getActiveBundleMetadataSnapshot(): ActiveBundleMetadataSnapshot? {
+        val activeBundleId =
+            getActiveBundleId() ?: run {
+                clearActiveBundleMetadataSnapshot()
+                return null
+            }
+
+        activeBundleMetadataSnapshot
+            ?.takeIf { it.activeBundleId == activeBundleId }
+            ?.let { return it }
+
+        synchronized(activeBundleMetadataLock) {
+            activeBundleMetadataSnapshot
+                ?.takeIf { it.activeBundleId == activeBundleId }
+                ?.let { return it }
+
+            val bundleDir = File(getBundleStoreDir(), activeBundleId)
+            if (!bundleDir.exists()) {
+                activeBundleMetadataSnapshot = null
+                return null
+            }
+
+            return resolveActiveBundleMetadataSnapshot(bundleDir).also {
+                activeBundleMetadataSnapshot = it
+            }
+        }
+    }
+
+    private fun clearActiveBundleMetadataSnapshot() {
+        synchronized(activeBundleMetadataLock) {
+            activeBundleMetadataSnapshot = null
+        }
+    }
+
+    private fun resolveActiveBundleMetadataSnapshot(bundleDir: File): ActiveBundleMetadataSnapshot {
+        val manifest = readManifestFromBundleDir(bundleDir) ?: emptyMap()
+        val manifestBundleId =
+            (manifest["bundleId"] as? String)
+                ?.trim()
+                ?.takeIf { it.isNotEmpty() }
+
+        return ActiveBundleMetadataSnapshot(
+            activeBundleId = bundleDir.name,
+            bundleId = manifestBundleId ?: readCompatibilityBundleIdFromBundleDir(bundleDir),
+            manifest = manifest,
+        )
+    }
+
+    private fun readCompatibilityBundleIdFromBundleDir(bundleDir: File): String? {
+        val compatibilityBundleIdFile = File(bundleDir, compatibilityBundleIdFilename())
+        if (!compatibilityBundleIdFile.exists()) {
+            return null
+        }
+
+        return try {
+            compatibilityBundleIdFile.readText().trim().takeIf { it.isNotEmpty() }
+        } catch (e: Exception) {
+            Log.w(
+                TAG,
+                "Failed to read compatibility bundle metadata from ${compatibilityBundleIdFile.absolutePath}: ${e.message}",
+            )
+            null
+        }
+    }
+
+    private fun compatibilityBundleIdFilename(): String = "BUNDLE_ID"
+
+    private fun readManifestFromBundleDir(bundleDir: File): Map<String, Any?>? {
+        val manifestFile = File(bundleDir, "manifest.json")
+        if (!manifestFile.exists()) {
+            return null
+        }
+
+        return try {
+            JSONObject(manifestFile.readText()).let(::jsonObjectToMap)
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to read manifest from ${manifestFile.absolutePath}: ${e.message}")
+            null
+        }
+    }
+
+    private fun jsonObjectToMap(jsonObject: JSONObject): Map<String, Any?> {
+        val result = linkedMapOf<String, Any?>()
+        val keys = jsonObject.keys()
+
+        while (keys.hasNext()) {
+            val key = keys.next()
+            result[key] = jsonValueToKotlin(jsonObject.opt(key))
+        }
+
+        return result
+    }
+
+    private fun jsonArrayToList(jsonArray: org.json.JSONArray): List<Any?> =
+        List(jsonArray.length()) { index ->
+            jsonValueToKotlin(jsonArray.opt(index))
+        }
+
+    private fun jsonValueToKotlin(value: Any?): Any? =
+        when (value) {
+            JSONObject.NULL -> null
+            is JSONObject -> jsonObjectToMap(value)
+            is org.json.JSONArray -> jsonArrayToList(value)
+            else -> value
+        }
+
     /**
      * Checks if isolationKey has changed and cleans up old bundles if needed.
      * This handles migration when isolationKey format changes.
@@ -213,95 +385,110 @@ class BundleFileStorageService(
 
     private fun isVerificationPending(metadata: BundleMetadata): Boolean = metadata.verificationPending && metadata.stagingBundleId != null
 
-    private fun wasVerificationAttempted(metadata: BundleMetadata): Boolean = metadata.verificationAttemptedAt != null
-
-    private fun markVerificationAttempted() {
-        val metadata = loadMetadataOrNull() ?: return
-        val updatedMetadata =
-            metadata.copy(
-                verificationAttemptedAt = System.currentTimeMillis(),
-                updatedAt = System.currentTimeMillis(),
-            )
-        saveMetadata(updatedMetadata)
-        Log.d(TAG, "Marked verification attempted at ${updatedMetadata.verificationAttemptedAt}")
+    private fun prepareMetadataForNewStagingBundle(
+        metadata: BundleMetadata,
+        bundleId: String,
+    ): BundleMetadata {
+        val currentVerifiedBundleId =
+            getCurrentVerifiedBundleId(metadata)?.takeIf { it != bundleId }
+
+        return metadata.copy(
+            stableBundleId = currentVerifiedBundleId,
+            stagingBundleId = bundleId,
+            verificationPending = true,
+            updatedAt = System.currentTimeMillis(),
+        )
     }
 
-    private fun promoteStagingToStable() {
-        val metadata = loadMetadataOrNull() ?: return
-        val stagingBundleId = metadata.stagingBundleId ?: return
+    private fun rollbackPendingBundle(stagingBundleId: String): Boolean {
+        val metadata = loadMetadataOrNull() ?: return false
+        if (metadata.stagingBundleId != stagingBundleId) {
+            return false
+        }
+
+        Log.w(TAG, "Rolling back crashed staging bundle: $stagingBundleId")
+
+        val crashedHistory = loadCrashedHistory()
+        crashedHistory.addEntry(stagingBundleId)
+        saveCrashedHistory(crashedHistory)
 
-        Log.d(TAG, "Promoting staging bundle $stagingBundleId to stable")
+        val fallbackBundleId =
+            metadata.stableBundleId?.takeIf { candidate ->
+                getBundleUrlForId(candidate) != null
+            }
 
         val updatedMetadata =
             metadata.copy(
-                stableBundleId = stagingBundleId,
-                stagingBundleId = null,
+                stableBundleId = null,
+                stagingBundleId = fallbackBundleId,
                 verificationPending = false,
-                verificationAttemptedAt = null,
                 updatedAt = System.currentTimeMillis(),
             )
         saveMetadata(updatedMetadata)
 
-        // Update HotUpdaterBundleURL preference to point to stable bundle
-        val bundleStoreDir = getBundleStoreDir()
-        val stableBundleDir = File(bundleStoreDir, stagingBundleId)
-        val bundleFile = stableBundleDir.walk().find { it.name == "index.android.bundle" }
-        if (bundleFile != null) {
-            preferences.setItem("HotUpdaterBundleURL", bundleFile.absolutePath)
-        }
+        val fallbackBundleUrl = fallbackBundleId?.let { getBundleUrlForId(it) }
+        setBundleURL(fallbackBundleUrl)
 
-        // Cleanup old bundles (keep only the new stable)
-        cleanupOldBundles(bundleStoreDir, null, stagingBundleId)
+        File(getBundleStoreDir(), stagingBundleId).deleteRecursively()
+        saveLaunchReport(LaunchReport(status = "RECOVERED", crashedBundleId = stagingBundleId))
+        return true
     }
 
-    private fun rollbackToStable() {
+    private fun applyPendingRecoveryIfNeeded(pendingRecovery: PendingCrashRecovery?) {
         val metadata = loadMetadataOrNull() ?: return
         val stagingBundleId = metadata.stagingBundleId ?: return
 
-        Log.w(TAG, "Rolling back: adding $stagingBundleId to crashed history")
-
-        // Add to crashed history
-        val crashedHistory = loadCrashedHistory()
-        crashedHistory.addEntry(stagingBundleId)
-        saveCrashedHistory(crashedHistory)
-
-        // Save rollback info to session variable (memory only)
-        sessionRollbackBundleId = stagingBundleId
+        if (pendingRecovery?.shouldRollback == true &&
+            pendingRecovery.launchedBundleId == stagingBundleId &&
+            isVerificationPending(metadata)
+        ) {
+            rollbackPendingBundle(stagingBundleId)
+        }
+    }
 
-        // Clear staging pointer
-        val updatedMetadata =
-            metadata.copy(
-                stagingBundleId = null,
-                verificationPending = false,
-                verificationAttemptedAt = null,
-                stagingExecutionCount = null,
-                updatedAt = System.currentTimeMillis(),
+    private fun selectLaunch(): LaunchSelection {
+        val metadata = loadMetadataOrNull()
+        if (metadata == null) {
+            val cached = getCachedBundleURL()
+            return LaunchSelection(
+                bundleUrl = cached ?: getFallbackBundleURL(),
+                launchedBundleId = extractBundleIdFromCurrentURL(),
+                shouldRollbackOnCrash = false,
             )
-        saveMetadata(updatedMetadata)
+        }
+
+        metadata.stagingBundleId?.let { stagingBundleId ->
+            val stagingBundleUrl = getBundleUrlForId(stagingBundleId)
+            if (stagingBundleUrl != null) {
+                return LaunchSelection(
+                    bundleUrl = stagingBundleUrl,
+                    launchedBundleId = stagingBundleId,
+                    shouldRollbackOnCrash = metadata.verificationPending,
+                )
+            }
 
-        // Update bundle URL to point to stable bundle
-        val stableBundleId = updatedMetadata.stableBundleId
-        if (stableBundleId != null) {
-            val bundleStoreDir = getBundleStoreDir()
-            val stableBundleDir = File(bundleStoreDir, stableBundleId)
-            val bundleFile = stableBundleDir.walk().find { it.name == "index.android.bundle" }
-            if (bundleFile != null && bundleFile.exists()) {
-                setBundleURL(bundleFile.absolutePath)
-                Log.d(TAG, "Updated bundle URL to stable: $stableBundleId")
+            if (metadata.verificationPending && rollbackPendingBundle(stagingBundleId)) {
+                return selectLaunch()
             }
-        } else {
-            // No stable bundle available, clear bundle URL (fallback to assets)
-            setBundleURL(null)
-            Log.d(TAG, "Cleared bundle URL (no stable bundle)")
         }
 
-        // Remove staging bundle directory
-        val bundleStoreDir = getBundleStoreDir()
-        val stagingBundleDir = File(bundleStoreDir, stagingBundleId)
-        if (stagingBundleDir.exists()) {
-            stagingBundleDir.deleteRecursively()
-            Log.d(TAG, "Deleted crashed staging bundle directory: $stagingBundleId")
+        metadata.stableBundleId?.let { stableBundleId ->
+            val stableBundleUrl = getBundleUrlForId(stableBundleId)
+            if (stableBundleUrl != null) {
+                return LaunchSelection(
+                    bundleUrl = stableBundleUrl,
+                    launchedBundleId = stableBundleId,
+                    shouldRollbackOnCrash = false,
+                )
+            }
         }
+
+        val cached = getCachedBundleURL()
+        return LaunchSelection(
+            bundleUrl = cached ?: getFallbackBundleURL(),
+            launchedBundleId = extractBundleIdFromCurrentURL(),
+            shouldRollbackOnCrash = false,
+        )
     }
 
     // MARK: - Crashed History
@@ -321,41 +508,29 @@ class BundleFileStorageService(
         return true
     }
 
-    // MARK: - notifyAppReady
-
-    override fun notifyAppReady(currentBundleId: String?): Map<String, Any?> {
-        val metadata =
-            loadMetadataOrNull()
-                ?: return mapOf("status" to "STABLE")
-
-        // Check if there was a recent rollback (session variable)
-        sessionRollbackBundleId?.let { crashedBundleId ->
-            // Clear rollback info (one-time read)
-            sessionRollbackBundleId = null
-
-            Log.d(TAG, "notifyAppReady: recovered from rollback (crashed bundle: $crashedBundleId)")
-            return mapOf(
-                "status" to "RECOVERED",
-                "crashedBundleId" to crashedBundleId,
-            )
+    override fun markLaunchCompleted(currentBundleId: String?) {
+        val metadata = loadMetadataOrNull() ?: return
+        val stagingBundleId = metadata.stagingBundleId ?: return
+        if (!metadata.verificationPending || stagingBundleId != currentBundleId) {
+            return
         }
 
-        // Check for promotion
-        if (isVerificationPending(metadata)) {
-            val stagingBundleId = metadata.stagingBundleId
-            if (stagingBundleId != null && stagingBundleId == currentBundleId) {
-                Log.d(TAG, "App started successfully with staging bundle $currentBundleId, promoting to stable")
-                promoteStagingToStable()
-                return mapOf("status" to "PROMOTED")
-            } else {
-                Log.d(TAG, "notifyAppReady: bundleId mismatch (staging=$stagingBundleId, current=$currentBundleId)")
-            }
-        } else {
-            Log.d(TAG, "notifyAppReady: no verification pending")
-        }
+        saveMetadata(
+            metadata.copy(
+                verificationPending = false,
+                updatedAt = System.currentTimeMillis(),
+            ),
+        )
+    }
 
-        // No changes
-        return mapOf("status" to "STABLE")
+    // MARK: - notifyAppReady
+
+    override fun notifyAppReady(): Map<String, Any?> {
+        val report = loadLaunchReport() ?: return mapOf("status" to "STABLE")
+        return buildMap {
+            put("status", report.status)
+            report.crashedBundleId?.let { put("crashedBundleId", it) }
+        }
     }
 
     // MARK: - Bundle URL Operations
@@ -363,6 +538,7 @@ class BundleFileStorageService(
     override fun setBundleURL(localPath: String?): Boolean {
         Log.d(TAG, "setBundleURL: $localPath")
         preferences.setItem("HotUpdaterBundleURL", localPath)
+        clearActiveBundleMetadataSnapshot()
         return true
     }
 
@@ -387,73 +563,16 @@ class BundleFileStorageService(
 
     override fun getFallbackBundleURL(): String = "assets://index.android.bundle"
 
-    // Track if crash detection has already run in this process
-    private var crashDetectionCompleted = false
-
-    override fun getBundleURL(): String {
-        val metadata = loadMetadataOrNull()
-
-        if (metadata == null) {
-            // Legacy mode: no metadata.json exists, use existing behavior
-            val cached = getCachedBundleURL()
-            val result = cached ?: getFallbackBundleURL()
-            Log.d(TAG, "getBundleURL (legacy): returning $result")
-            return result
-        }
-
-        // New rollback-aware mode - only run crash detection ONCE per process
-        if (isVerificationPending(metadata) && !crashDetectionCompleted) {
-            crashDetectionCompleted = true
-
-            if (wasVerificationAttempted(metadata)) {
-                // Already executed once but didn't call notifyAppReady → crash!
-                Log.w(TAG, "Crash detected: staging bundle executed but didn't call notifyAppReady")
-                rollbackToStable()
-            } else {
-                // First execution - mark verification attempted and give it a chance
-                Log.d(TAG, "First execution of staging bundle, marking verification attempted")
-                markVerificationAttempted()
-            }
-        }
+    override fun prepareLaunch(pendingRecovery: PendingCrashRecovery?): LaunchSelection {
+        saveLaunchReport(null)
+        applyPendingRecoveryIfNeeded(pendingRecovery)
 
-        // Reload metadata after potential rollback
-        val currentMetadata = loadMetadataOrNull()
-
-        // Return staging bundle if verification pending
-        if (currentMetadata != null && isVerificationPending(currentMetadata)) {
-            val stagingId = currentMetadata.stagingBundleId
-            if (stagingId != null) {
-                val bundleStoreDir = getBundleStoreDir()
-                val stagingBundleDir = File(bundleStoreDir, stagingId)
-                val bundleFile = stagingBundleDir.walk().find { it.name == "index.android.bundle" }
-                if (bundleFile != null && bundleFile.exists()) {
-                    Log.d(TAG, "getBundleURL: returning STAGING bundle $stagingId")
-                    return bundleFile.absolutePath
-                } else {
-                    Log.w(TAG, "getBundleURL: staging bundle file not found for $stagingId")
-                    // Staging bundle file missing, rollback to stable
-                    rollbackToStable()
-                }
-            }
-        }
-
-        // Return stable bundle URL
-        val stableBundleId = currentMetadata?.stableBundleId
-        if (stableBundleId != null) {
-            val bundleStoreDir = getBundleStoreDir()
-            val stableBundleDir = File(bundleStoreDir, stableBundleId)
-            val bundleFile = stableBundleDir.walk().find { it.name == "index.android.bundle" }
-            if (bundleFile != null && bundleFile.exists()) {
-                Log.d(TAG, "getBundleURL: returning stable bundle $stableBundleId")
-                return bundleFile.absolutePath
-            }
-        }
-
-        // Fallback
-        val cached = getCachedBundleURL()
-        val result = cached ?: getFallbackBundleURL()
-        Log.d(TAG, "getBundleURL: returning $result (cached=$cached)")
-        return result
+        val selection = selectLaunch()
+        Log.d(
+            TAG,
+            "prepareLaunch: bundleId=${selection.launchedBundleId} shouldRollback=${selection.shouldRollbackOnCrash} url=${selection.bundleUrl}",
+        )
+        return selection
     }
 
     override suspend fun updateBundle(
@@ -525,23 +644,16 @@ class BundleFileStorageService(
 
                 // Update metadata: set as staging
                 val currentMetadata = loadMetadataOrNull() ?: createInitialMetadata()
-                val updatedMetadata =
-                    currentMetadata.copy(
-                        stagingBundleId = bundleId,
-                        verificationPending = true,
-                        verificationAttemptedAt = null,
-                        updatedAt = System.currentTimeMillis(),
-                    )
+                val updatedMetadata = prepareMetadataForNewStagingBundle(currentMetadata, bundleId)
                 saveMetadata(updatedMetadata)
 
                 // Set bundle URL for backwards compatibility
                 setBundleURL(existingIndexFile.absolutePath)
 
-                // Keep both stable and staging bundles
-                val stableBundleId = currentMetadata.stableBundleId
-                cleanupOldBundles(bundleStoreDir, stableBundleId, bundleId)
+                // Keep the current verified bundle as a fallback if one exists.
+                cleanupOldBundles(bundleStoreDir, updatedMetadata.stableBundleId, bundleId)
 
-                Log.d(TAG, "Existing bundle set as staging, will be promoted after notifyAppReady")
+                Log.d(TAG, "Existing bundle set as staging bundle for next launch")
                 return
             } else {
                 // If index.android.bundle is missing, delete and re-download
@@ -721,13 +833,7 @@ class BundleFileStorageService(
 
                     // Update metadata: set new bundle as staging
                     val currentMetadata = loadMetadataOrNull() ?: createInitialMetadata()
-                    val updatedMetadata =
-                        currentMetadata.copy(
-                            stagingBundleId = bundleId,
-                            verificationPending = true,
-                            verificationAttemptedAt = null,
-                            updatedAt = System.currentTimeMillis(),
-                        )
+                    val updatedMetadata = prepareMetadataForNewStagingBundle(currentMetadata, bundleId)
                     saveMetadata(updatedMetadata)
 
                     // Also update HotUpdaterBundleURL for backwards compatibility
@@ -737,11 +843,10 @@ class BundleFileStorageService(
                     // 11) Clean up temporary and download folders
                     tempDir.deleteRecursively()
 
-                    // 12) Keep both stable and staging bundles
-                    val stableBundleId = currentMetadata.stableBundleId
-                    cleanupOldBundles(bundleStoreDir, stableBundleId, bundleId)
+                    // 12) Keep the fallback bundle and the new staging bundle.
+                    cleanupOldBundles(bundleStoreDir, updatedMetadata.stableBundleId, bundleId)
 
-                    Log.d(TAG, "Downloaded and set bundle as staging successfully. Will be promoted after notifyAppReady.")
+                    Log.d(TAG, "Downloaded and set bundle as staging successfully for the next launch.")
                     // Progress already at 1.0 from unzip completion
                 }
             }
@@ -813,14 +918,7 @@ class BundleFileStorageService(
      */
     override fun getBaseURL(): String {
         return try {
-            val metadata = loadMetadataOrNull()
-            val activeBundleId =
-                when {
-                    metadata?.verificationPending == true && metadata.stagingBundleId != null ->
-                        metadata.stagingBundleId
-                    metadata?.stableBundleId != null -> metadata.stableBundleId
-                    else -> extractBundleIdFromCurrentURL()
-                }
+            val activeBundleId = getActiveBundleId()
 
             if (activeBundleId != null) {
                 val bundleDir = File(getBundleStoreDir(), activeBundleId)
@@ -836,6 +934,22 @@ class BundleFileStorageService(
         }
     }
 
+    override fun getBundleId(): String? =
+        try {
+            getActiveBundleMetadataSnapshot()?.bundleId
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting bundle ID: ${e.message}")
+            null
+        }
+
+    override fun getManifest(): Map<String, Any?> =
+        try {
+            getActiveBundleMetadataSnapshot()?.manifest ?: emptyMap()
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting manifest: ${e.message}")
+            emptyMap()
+        }
+
     override suspend fun resetChannel(): Boolean =
         withContext(Dispatchers.IO) {
             if (!setBundleURL(null)) {
@@ -848,18 +962,19 @@ class BundleFileStorageService(
                     stableBundleId = null,
                     stagingBundleId = null,
                     verificationPending = false,
-                    verificationAttemptedAt = null,
-                    stagingExecutionCount = null,
                 )
 
             if (!saveMetadata(clearedMetadata)) {
                 return@withContext false
             }
 
+            saveLaunchReport(null)
+
             getBundleStoreDir().listFiles()?.forEach { file ->
                 if (
                     file.name == BundleMetadata.METADATA_FILENAME ||
-                    file.name == CrashedHistory.CRASHED_HISTORY_FILENAME
+                    file.name == CrashedHistory.CRASHED_HISTORY_FILENAME ||
+                    file.name == LaunchReport.LAUNCH_REPORT_FILENAME
                 ) {
                     return@forEach
                 }