expo-updates 55.0.27 → 55.0.29

package/CHANGELOG.md

@@ -10,6 +10,27 @@
 
 ### 💡 Others
 
+## 55.0.29 — 2026-08-27
+
+### 🐛 Bug fixes
+
+- [Android] Widen `UpdatesLogEntry.create`'s catch from `JSONException` to `Exception` so log-line parse failures consistently degrade to "skip the entry" instead of propagating. ([#46182](https://github.com/expo/expo/pull/46182) by [@jakequade-pc](https://github.com/jakequade-pc))
+- [Android] Correct `UpdatesLogReader.ONE_DAY_MILLISECONDS` from `86400` (seconds) to `86_400_000` (milliseconds), so the "older than one day" purge filter actually retains a day's worth of entries instead of ~86 seconds' worth. ([#46182](https://github.com/expo/expo/pull/46182) by [@jakequade-pc](https://github.com/jakequade-pc))
+
+### 💡 Others
+
+- [Android] Log purge completion errors via `android.util.Log.e` directly instead of `logger.error`, so the failure path doesn't re-enter the `PersistentFileLog` dispatch queue from inside one of its own tasks. ([#46182](https://github.com/expo/expo/pull/46182) by [@jakequade-pc](https://github.com/jakequade-pc))
+
+## 55.0.28 — 2026-08-25
+
+### 🐛 Bug fixes
+
+- [Android] Register the embedded update in a single transaction. An interrupted registration previously left an update row with no launch asset, which is treated as launchable and then fails every cold start with "Launch asset not found for update"; it now leaves no row, so the next launch registers it cleanly. ([#49130](https://github.com/expo/expo/pull/49130) by [@gwdp](https://github.com/gwdp))
+
+### 💡 Others
+
+- [Android] Replace the "this should never happen" wording in the missing launch asset error with the likely cause and how the state resolves. ([#49130](https://github.com/expo/expo/pull/49130) by [@gwdp](https://github.com/gwdp))
+
 ## 55.0.27 — 2026-08-17
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -42,7 +42,7 @@ expoModule {
 }
 
 group = 'host.exp.exponent'
-version = '55.0.27'
+version = '55.0.29'
 
 // Utility method to derive boolean values from the environment or from Java properties,
 // and return them as strings to be used in BuildConfig fields
@@ -89,7 +89,7 @@ android {
   namespace "expo.modules.updates"
   defaultConfig {
     versionCode 31
-    versionName '55.0.27'
+    versionName '55.0.29'
     consumerProguardFiles("proguard-rules.pro")
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 

package/android/src/main/java/expo/modules/updates/EnabledUpdatesController.kt

@@ -4,6 +4,7 @@ import android.app.Activity
 import android.content.Context
 import android.net.Uri
 import android.os.Bundle
+import android.util.Log
 import com.facebook.react.ReactHost
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.devsupport.interfaces.DevSupportManager
@@ -18,7 +19,6 @@ import expo.modules.updates.events.IUpdatesEventManager
 import expo.modules.updates.events.UpdatesEventManager
 import expo.modules.updates.launcher.Launcher.LauncherCallback
 import expo.modules.updates.loader.FileDownloader
-import expo.modules.updates.logging.UpdatesErrorCode
 import expo.modules.updates.logging.UpdatesLogReader
 import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.manifest.EmbeddedManifestUtils
@@ -35,6 +35,7 @@ import expo.modules.updates.statemachine.UpdatesStateValue
 import expo.modules.updatesinterface.UpdatesInterface
 import expo.modules.updatesinterface.UpdatesStateChangeListener
 import expo.modules.updatesinterface.UpdatesStateChangeSubscription
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -89,7 +90,12 @@ class EnabledUpdatesController(
   private fun purgeUpdatesLogsOlderThanOneDay() {
     UpdatesLogReader(context.filesDir).purgeLogEntries {
       if (it != null) {
-        logger.error("UpdatesLogReader: error in purgeLogEntries", it, UpdatesErrorCode.Unknown)
+        // Log directly via android.util.Log rather than through `logger.error`,
+        // which writes via the PersistentFileLog dispatch queue. This callback
+        // is invoked from inside one of that queue's own tasks, so feeding
+        // another entry back into the queue from here re-enters it. Bypassing
+        // the queue keeps the failure path off its own back.
+        Log.e("expo-updates", "UpdatesLogReader: error in purgeLogEntries", it)
       }
     }
   }
@@ -256,7 +262,7 @@ class EnabledUpdatesController(
   }
 
   override suspend fun fetchUpdate() = suspendCancellableCoroutine { continuation ->
-    val procedure = FetchUpdateProcedure(context, updatesConfiguration, logger, databaseHolder, updatesDirectory, fileDownloader, selectionPolicy, launchedUpdate) {
+    val procedure = FetchUpdateProcedure(context, updatesConfiguration, logger, databaseHolder, updatesDirectory, fileDownloader, selectionPolicy, launchedUpdate, controllerScope) {
       continuation.resume(it)
     }
     stateMachine.queueExecution(procedure)
@@ -280,6 +286,8 @@ class EnabledUpdatesController(
           }
         }
         continuation.resume(resultMap)
+      } catch (e: CancellationException) {
+        throw e
       } catch (e: Exception) {
         continuation.resumeWithException(e.toCodedException())
       }
@@ -288,7 +296,7 @@ class EnabledUpdatesController(
 
   override suspend fun setExtraParam(key: String, value: String?) = suspendCancellableCoroutine { continuation ->
     controllerScope.launch {
-      runCatching {
+      try {
         ManifestMetadata.setExtraParam(
           databaseHolder.database,
           updatesConfiguration,
@@ -296,7 +304,9 @@ class EnabledUpdatesController(
           value
         )
         continuation.resume(Unit)
-      }.onFailure { e ->
+      } catch (e: CancellationException) {
+        throw e
+      } catch (e: Exception) {
         continuation.resumeWithException(e.toCodedException())
       }
     }

package/android/src/main/java/expo/modules/updates/UpdatesDevLauncherController.kt

@@ -34,9 +34,11 @@ import expo.modules.updatesinterface.UpdatesDevLauncherInterface
 import expo.modules.updatesinterface.UpdatesInterfaceCallbacks
 import expo.modules.updatesinterface.UpdatesStateChangeListener
 import expo.modules.updatesinterface.UpdatesStateChangeSubscription
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
 import org.json.JSONObject
@@ -183,7 +185,8 @@ class UpdatesDevLauncherController(
       databaseHolder.database,
       fileDownloader,
       updatesDirectory,
-      null
+      null,
+      controllerScope
     )
     controllerScope.launch {
       val progressJob = launch {
@@ -215,6 +218,8 @@ class UpdatesDevLauncherController(
           return@launch
         }
         launchUpdate(loaderResult.updateEntity, updatesConfiguration!!, fileDownloader, callback)
+      } catch (e: CancellationException) {
+        throw e
       } catch (e: Exception) {
         // reset controller's configuration to what it was before this request
         updatesConfiguration = previousUpdatesConfiguration
@@ -309,6 +314,8 @@ class UpdatesDevLauncherController(
           get() = launcher.launchAssetFile!!
       })
       runReaper()
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       // reset controller's configuration to what it was before this request
       updatesConfiguration = previousUpdatesConfiguration
@@ -385,7 +392,7 @@ class UpdatesDevLauncherController(
   }
 
   override fun shutdown() {
-    // no-op
+    controllerScope.cancel()
   }
 
   companion object {

package/android/src/main/java/expo/modules/updates/launcher/DatabaseLauncher.kt

@@ -87,7 +87,7 @@ class DatabaseLauncher(
     // verify that we have all assets on disk
     // according to the database, we should, but something could have gone wrong on disk
     val launchAsset = database.updateDao().loadLaunchAssetForUpdate(launchedUpdate!!.id)
-      ?: throw Exception("Launch asset not found for update; this should never happen. Debug info: ${launchedUpdate!!.debugInfo()}")
+      ?: throw Exception("Launch asset not found for update. The update row has no launch asset; an interrupted registration in an older version of expo-updates can leave an update in this state, and it is replaced once a newer update is downloaded. Debug info: ${launchedUpdate!!.debugInfo()}")
 
     if (launchAsset.relativePath == null) {
       throw Exception("Launch asset relative path should not be null. Debug info: ${launchedUpdate!!.debugInfo()}")

package/android/src/main/java/expo/modules/updates/loader/EmbeddedLoader.kt

@@ -9,6 +9,9 @@ import expo.modules.updates.UpdatesUtils
 import expo.modules.updates.db.entity.UpdateEntity
 import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.utils.AndroidResourceAssetUtils
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import java.io.File
 import java.io.FileNotFoundException
 import java.lang.AssertionError
@@ -32,14 +35,16 @@ class EmbeddedLoader internal constructor(
   database: UpdatesDatabase,
   updatesDirectory: File,
   private val loaderFiles: LoaderFiles,
-  private val shouldCopyEmbeddedAssets: Boolean = BuildConfig.EX_UPDATES_COPY_EMBEDDED_ASSETS
+  private val shouldCopyEmbeddedAssets: Boolean = BuildConfig.EX_UPDATES_COPY_EMBEDDED_ASSETS,
+  scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 ) : Loader(
   context,
   configuration,
   logger,
   database,
   updatesDirectory,
-  loaderFiles
+  loaderFiles,
+  scope
 ) {
 
   constructor(
@@ -47,8 +52,9 @@ class EmbeddedLoader internal constructor(
     configuration: UpdatesConfiguration,
     logger: UpdatesLogger,
     database: UpdatesDatabase,
-    updatesDirectory: File
-  ) : this(context, configuration, logger, database, updatesDirectory, LoaderFiles())
+    updatesDirectory: File,
+    scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+  ) : this(context, configuration, logger, database, updatesDirectory, LoaderFiles(), scope = scope)
 
   override suspend fun loadRemoteUpdate(
     database: UpdatesDatabase,

package/android/src/main/java/expo/modules/updates/loader/Loader.kt

@@ -1,6 +1,7 @@
 package expo.modules.updates.loader
 
 import android.content.Context
+import androidx.room.withTransaction
 import expo.modules.updates.UpdatesConfiguration
 import expo.modules.updates.UpdatesUtils
 import expo.modules.updates.db.UpdatesDatabase
@@ -17,12 +18,14 @@ import expo.modules.updates.logging.UpdatesErrorCode
 import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.manifest.ManifestMetadata
 import expo.modules.updates.manifest.Update
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import java.io.File
 import java.io.IOException
 import java.util.*
+import java.util.Collections
 import java.util.concurrent.ConcurrentHashMap
 
 /**
@@ -44,9 +47,9 @@ abstract class Loader protected constructor(
   private var updateResponse: UpdateResponse? = null
   private var updateEntity: UpdateEntity? = null
   private var assetTotal = 0
-  private var erroredAssetList = mutableListOf<AssetEntity>()
-  private var existingAssetList = mutableListOf<AssetEntity>()
-  private var finishedAssetList = mutableListOf<AssetEntity>()
+  private var erroredAssetList: MutableList<AssetEntity> = Collections.synchronizedList(mutableListOf())
+  private var existingAssetList: MutableList<AssetEntity> = Collections.synchronizedList(mutableListOf())
+  private var finishedAssetList: MutableList<AssetEntity> = Collections.synchronizedList(mutableListOf())
   private val _progressFlow = MutableSharedFlow<AssetLoadProgress>()
   private var assetProgressMap: MutableMap<AssetEntity, Double> = ConcurrentHashMap()
 
@@ -115,9 +118,9 @@ abstract class Loader protected constructor(
     updateResponse = null
     updateEntity = null
     assetTotal = 0
-    erroredAssetList = mutableListOf()
-    existingAssetList = mutableListOf()
-    finishedAssetList = mutableListOf()
+    erroredAssetList = Collections.synchronizedList(mutableListOf())
+    existingAssetList = Collections.synchronizedList(mutableListOf())
+    finishedAssetList = Collections.synchronizedList(mutableListOf())
     assetProgressMap = ConcurrentHashMap()
     assetLoadProgressBlock = null
   }
@@ -168,16 +171,23 @@ abstract class Loader protected constructor(
       updateEntity = existingUpdateEntity
       return finish()
     } else {
+      val insertUpdateEntityOnFinish: Boolean
       if (existingUpdateEntity == null) {
-        // no update already exists with this ID, so we need to insert it and download everything.
+        // no update already exists with this ID, so we need to download everything.
         updateEntity = newUpdateEntity
-        database.updateDao().insertUpdate(updateEntity!!)
+        // EMBEDDED is already in the launchable set, so a row inserted before its launch asset exists
+        // gets picked as launchable and then fails every launch.
+        insertUpdateEntityOnFinish = newUpdateEntity.status == UpdateStatus.EMBEDDED
+        if (!insertUpdateEntityOnFinish) {
+          database.updateDao().insertUpdate(updateEntity!!)
+        }
       } else {
         // we've already partially downloaded the update, so we should use the existing entity.
         // however, it's not ready, so we should try to download all the assets again.
         updateEntity = existingUpdateEntity
+        insertUpdateEntityOnFinish = false
       }
-      return downloadAllAssets(update)
+      return downloadAllAssets(update, insertUpdateEntityOnFinish)
     }
   }
 
@@ -187,7 +197,7 @@ abstract class Loader protected constructor(
     ERRORED
   }
 
-  private suspend fun downloadAllAssets(update: Update): LoaderResult {
+  private suspend fun downloadAllAssets(update: Update, insertUpdateEntityOnFinish: Boolean): LoaderResult {
     val assetList = update.assetEntityList.distinctBy { it.key }
     assetTotal = assetList.size
 
@@ -234,26 +244,34 @@ abstract class Loader protected constructor(
     assetDownloadJobs.awaitAll()
 
     try {
-      for (asset in existingAssetList) {
-        val existingAssetFound = database.assetDao()
-          .addExistingAssetToUpdate(updateEntity!!, asset, asset.isLaunchAsset)
-        if (!existingAssetFound) {
-          // the database and filesystem have gotten out of sync
-          // do our best to create a new entry for this file even though it already existed on disk
-          // TODO: we should probably get rid of this assumption that if an asset exists on disk with the same filename, it's the same asset
-          var hash: ByteArray? = null
-          try {
-            hash = UpdatesUtils.sha256(File(updatesDirectory, asset.relativePath))
-          } catch (_: Exception) {
+      database.withTransaction {
+        if (insertUpdateEntityOnFinish) {
+          database.updateDao().insertUpdate(updateEntity!!)
+        }
+
+        for (asset in existingAssetList) {
+          val existingAssetFound = database.assetDao()
+            .addExistingAssetToUpdate(updateEntity!!, asset, asset.isLaunchAsset)
+          if (!existingAssetFound) {
+            // the database and filesystem have gotten out of sync
+            // do our best to create a new entry for this file even though it already existed on disk
+            // TODO: we should probably get rid of this assumption that if an asset exists on disk with the same filename, it's the same asset
+            var hash: ByteArray? = null
+            try {
+              hash = UpdatesUtils.sha256(File(updatesDirectory, asset.relativePath))
+            } catch (_: Exception) {
+            }
+            asset.downloadTime = Date()
+            asset.hash = hash
+            finishedAssetList.add(asset)
           }
-          asset.downloadTime = Date()
-          asset.hash = hash
-          finishedAssetList.add(asset)
         }
-      }
 
-      database.assetDao().insertAssets(finishedAssetList, updateEntity!!)
-      database.updateDao().markUpdateFinished(updateEntity!!)
+        database.assetDao().insertAssets(finishedAssetList, updateEntity!!)
+        database.updateDao().markUpdateFinished(updateEntity!!)
+      }
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       throw IOException("Error while adding new update to database", e)
     }

package/android/src/main/java/expo/modules/updates/loader/LoaderTask.kt

@@ -17,6 +17,7 @@ import expo.modules.updates.manifest.EmbeddedManifestUtils
 import expo.modules.updates.manifest.ManifestMetadata
 import expo.modules.updates.manifest.Update
 import expo.modules.updates.selectionpolicy.SelectionPolicy
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.CoroutineScope
 import org.json.JSONObject
@@ -189,6 +190,8 @@ class LoaderTask(
           callback.onFinishedAllLoading()
         }
       }
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       if (!shouldCheckForUpdate) {
         finish(e)
@@ -209,6 +212,8 @@ class LoaderTask(
       isRunning = false
       runReaper()
       callback.onFinishedAllLoading()
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       finish(e)
       isRunning = false
@@ -296,10 +301,12 @@ class LoaderTask(
         )
       ) {
         try {
-          val embeddedLoader = EmbeddedLoader(context, configuration, logger, database, directory)
+          val embeddedLoader = EmbeddedLoader(context, configuration, logger, database, directory, scope)
           embeddedLoader.load { _ ->
             Loader.OnUpdateResponseLoadedResult(shouldDownloadManifestIfPresentInResponse = true)
           }
+        } catch (e: CancellationException) {
+          throw e
         } catch (e: Exception) {
           logger.error("Unexpected error copying embedded update", e, UpdatesErrorCode.Unknown)
         }
@@ -315,7 +322,7 @@ class LoaderTask(
   private suspend fun launchRemoteUpdateInBackground() {
     val database = databaseHolder.database
     callback.onRemoteCheckForUpdateStarted()
-    val remoteLoader = RemoteLoader(context, configuration, logger, database, fileDownloader, directory, candidateLauncher?.launchedUpdate)
+    val remoteLoader = RemoteLoader(context, configuration, logger, database, fileDownloader, directory, candidateLauncher?.launchedUpdate, scope)
 
     remoteLoader.assetLoadProgressBlock = { progress ->
       callback.onRemoteUpdateProgressChanged(progress)

package/android/src/main/java/expo/modules/updates/loader/RemoteLoader.kt

@@ -10,6 +10,9 @@ import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.manifest.EmbeddedManifestUtils
 import expo.modules.updates.manifest.ManifestMetadata
 import expo.modules.updates.selectionpolicy.SelectionPolicy
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import java.io.File
 
 data class ProcessSuccessLoaderResult(
@@ -32,8 +35,9 @@ class RemoteLoader internal constructor(
   private val mFileDownloader: FileDownloader,
   updatesDirectory: File,
   private val launchedUpdate: UpdateEntity?,
-  private val loaderFiles: LoaderFiles
-) : Loader(context, configuration, logger, database, updatesDirectory, loaderFiles) {
+  private val loaderFiles: LoaderFiles,
+  scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+) : Loader(context, configuration, logger, database, updatesDirectory, loaderFiles, scope) {
   constructor(
     context: Context,
     configuration: UpdatesConfiguration,
@@ -41,8 +45,9 @@ class RemoteLoader internal constructor(
     database: UpdatesDatabase,
     fileDownloader: FileDownloader,
     updatesDirectory: File,
-    launchedUpdate: UpdateEntity?
-  ) : this(context, configuration, logger, database, fileDownloader, updatesDirectory, launchedUpdate, LoaderFiles())
+    launchedUpdate: UpdateEntity?,
+    scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+  ) : this(context, configuration, logger, database, fileDownloader, updatesDirectory, launchedUpdate, LoaderFiles(), scope)
 
   override suspend fun loadRemoteUpdate(
     database: UpdatesDatabase,

package/android/src/main/java/expo/modules/updates/logging/UpdatesLogEntry.kt

@@ -3,7 +3,6 @@ package expo.modules.updates.logging
 import expo.modules.jsonutils.getNullable
 import expo.modules.jsonutils.require
 import org.json.JSONArray
-import org.json.JSONException
 import org.json.JSONObject
 
 /**
@@ -59,7 +58,11 @@ data class UpdatesLogEntry(
             List(jsonArray.length()) { i -> jsonArray.getString(i) }
           }
         )
-      } catch (e: JSONException) {
+      } catch (e: Exception) {
+        // `JSONObject.require<T>` can surface a ClassCastException via a blind
+        // cast in the catch-all branch (e.g. an int-sized numeric `duration`
+        // token surfaces as `Integer`), which would otherwise escape and
+        // propagate to the caller.
         null
       }
     }

package/android/src/main/java/expo/modules/updates/logging/UpdatesLogReader.kt

@@ -54,6 +54,6 @@ class UpdatesLogReader(
   }
 
   companion object {
-    private const val ONE_DAY_MILLISECONDS = 86400
+    private const val ONE_DAY_MILLISECONDS = 86_400_000L
   }
 }

package/android/src/main/java/expo/modules/updates/procedures/CheckForUpdateProcedure.kt

@@ -43,6 +43,8 @@ class CheckForUpdateProcedure(
     try {
       val updateResponse = downloadRemoteUpdate(extraHeaders)
       processUpdatesResponse(updateResponse, procedureContext, embeddedUpdate)
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       procedureContext.processStateEvent(UpdatesStateEvent.CheckError(e.localizedMessageWithCauseLocalizedMessage()))
       callback(IUpdatesController.CheckForUpdateResult.ErrorResult(e))

package/android/src/main/java/expo/modules/updates/procedures/FetchUpdateProcedure.kt

@@ -14,6 +14,7 @@ import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.selectionpolicy.SelectionPolicy
 import expo.modules.updates.statemachine.UpdatesStateEvent
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
 import java.io.File
 
 class FetchUpdateProcedure(
@@ -25,6 +26,7 @@ class FetchUpdateProcedure(
   private val fileDownloader: FileDownloader,
   private val selectionPolicy: SelectionPolicy,
   private val launchedUpdate: UpdateEntity?,
+  private val scope: CoroutineScope,
   private val callback: (IUpdatesController.FetchUpdateResult) -> Unit
 ) : StateMachineProcedure() {
   override val loggerTimerLabel = "timer-fetch-update"
@@ -36,6 +38,8 @@ class FetchUpdateProcedure(
     try {
       val loaderResult = startRemoteLoader(database, procedureContext)
       processSuccessLoaderResult(loaderResult, procedureContext)
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       logger.error("Failed to download new update", e)
       procedureContext.processStateEvent(
@@ -55,7 +59,8 @@ class FetchUpdateProcedure(
       database,
       fileDownloader,
       updatesDirectory,
-      launchedUpdate
+      launchedUpdate,
+      scope
     )
 
     remoteLoader.assetLoadProgressBlock = { progress ->

package/android/src/main/java/expo/modules/updates/procedures/RelaunchProcedure.kt

@@ -13,6 +13,7 @@ import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.reloadscreen.ReloadScreenManager
 import expo.modules.updates.selectionpolicy.SelectionPolicy
 import expo.modules.updates.statemachine.UpdatesStateEvent
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -57,6 +58,8 @@ class RelaunchProcedure(
     )
     try {
       launchWith(newLauncher)
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       logger.error("Error launching new launcher", e, UpdatesErrorCode.Unknown)
       callback.onFailure(e)
@@ -91,6 +94,8 @@ class RelaunchProcedure(
           getCurrentLauncher().launchedUpdate,
           selectionPolicy
         )
+      } catch (e: CancellationException) {
+        throw e
       } catch (e: Exception) {
         logger.error("Could not run Reaper.", e, UpdatesErrorCode.Unknown)
       }

package/android/src/main/java/expo/modules/updates/procedures/StartupProcedure.kt

@@ -21,6 +21,7 @@ import expo.modules.updates.manifest.Update
 import expo.modules.updates.selectionpolicy.SelectionPolicy
 import expo.modules.updates.statemachine.UpdatesStateEvent
 import expo.modules.updates.statemachine.UpdatesStateValue
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -242,7 +243,7 @@ class StartupProcedure(
           return
         }
         remoteLoadStatus = ErrorRecoveryDelegate.RemoteLoadStatus.NEW_UPDATE_LOADING
-        val remoteLoader = RemoteLoader(context, updatesConfiguration, logger, databaseHolder.database, fileDownloader, updatesDirectory, launchedUpdate)
+        val remoteLoader = RemoteLoader(context, updatesConfiguration, logger, databaseHolder.database, fileDownloader, updatesDirectory, launchedUpdate, procedureScope)
         procedureScope.launch {
           try {
             val loaderResult = remoteLoader.load { updateResponse ->
@@ -267,6 +268,8 @@ class StartupProcedure(
                 ErrorRecoveryDelegate.RemoteLoadStatus.IDLE
               }
             )
+          } catch (e: CancellationException) {
+            throw e
           } catch (e: Exception) {
             logger.error("UpdatesController loadRemoteUpdate onFailure", e, UpdatesErrorCode.UpdateFailedToLoad, launchedUpdate?.loggingId, null)
             setRemoteLoadStatus(ErrorRecoveryDelegate.RemoteLoadStatus.IDLE)

package/android/src/main/java/expo/modules/updates/reloadscreen/ReloadScreenView.kt

@@ -11,6 +11,7 @@ import android.view.View
 import android.widget.FrameLayout
 import android.widget.ImageView
 import android.widget.ProgressBar
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
@@ -135,6 +136,8 @@ class ReloadScreenView @JvmOverloads constructor(
             imageView.setImageBitmap(it)
           } ?: handleImageLoadFailure()
         }
+      } catch (e: CancellationException) {
+        throw e
       } catch (e: Exception) {
         withContext(Dispatchers.Main) {
           handleImageLoadFailure()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-updates",
-  "version": "55.0.27",
+  "version": "55.0.29",
   "description": "Fetches and manages remotely-hosted assets and updates to your app's JS bundle.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -45,7 +45,7 @@
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "expo-eas-client": "~55.0.5",
-    "expo-manifests": "~55.0.20",
+    "expo-manifests": "~55.0.21",
     "expo-structured-headers": "~55.0.2",
     "expo-updates-interface": "~55.1.6",
     "getenv": "^2.0.0",
@@ -71,5 +71,5 @@
     "react": "*",
     "react-native": "*"
   },
-  "gitHead": "764641f87074c1e49d004790c5a5983f4b5bfc6b"
+  "gitHead": "5defc36eae34b72f7bee8385276200242e5458fe"
 }