expo-updates 56.0.25 → 56.0.27

package/CHANGELOG.md

@@ -10,6 +10,30 @@
 
 ### 💡 Others
 
+## 56.0.27 — 2026-09-17
+
+### 🐛 Bug fixes
+
+- [iOS] Apply bundle diffs against the embedded bundle in the app binary when the launched update is the embedded one, instead of failing to resolve a patch base and downloading the full bundle. ([#50018](https://github.com/expo/expo/pull/50018) by [@alanjhughes](https://github.com/alanjhughes))
+- [Android] Apply bundle diffs against the embedded bundle in the app binary when the launched update is the embedded one, instead of failing to resolve a patch base and downloading the full bundle. ([#50019](https://github.com/expo/expo/pull/50019) by [@alanjhughes](https://github.com/alanjhughes))
+
+## 56.0.26 — 2026-08-28
+
+### 🐛 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))
+- [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))
+- [iOS] Propagate database failures from `addNewAssets` instead of swallowing them, which let an update be marked ready without its launch asset and then fail every launch. ([#49456](https://github.com/expo/expo/pull/49456) by [@alanjhughes](https://github.com/alanjhughes))
+- [iOS] Repair ready updates that are missing their launch asset by demoting them to pending during launcher selection, so a corrupted row is skipped and retried instead of failing every launch. ([#49457](https://github.com/expo/expo/pull/49457) by [@alanjhughes](https://github.com/alanjhughes))
+- [Android] Skip and repair updates that are missing their launch asset instead of selecting them for launch, which previously failed every cold start with "Launch asset not found for update". ([#49470](https://github.com/expo/expo/pull/49470) by [@alanjhughes](https://github.com/alanjhughes), based on [#48733](https://github.com/expo/expo/pull/48733) by [@martintreurnicht](https://github.com/martintreurnicht))
+- [iOS] Fix the embedded manifest recording the wrong `packagerHash` for assets that ship scale variants iOS does not allow (such as `@1.5x` and `@4x`): the hashes were read by the filtered scale index instead of the asset's own, so those images resolved to an empty URI and rendered blank in release builds. ([#48811](https://github.com/expo/expo/pull/48811) by [@expo-bot](https://github.com/expo-bot))
+
+### 💡 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))
+- [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))
+
 ## 56.0.25 — 2026-08-17
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -42,7 +42,7 @@ expoModule {
 }
 
 group = 'host.exp.exponent'
-version = '56.0.25'
+version = '56.0.27'
 
 // 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 '56.0.25'
+    versionName '56.0.27'
     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
@@ -90,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)
       }
     }
   }

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()}")
@@ -161,6 +161,15 @@ class DatabaseLauncher(
       if (!configuration.hasEmbeddedUpdate && embeddedUpdate?.updateEntity?.id == update.id) {
         continue
       }
+
+      // An update with no launch asset can never launch. Excluding it here lets the loader
+      // re-run and repair the row instead of failing every cold start.
+      if (update.status != UpdateStatus.DEVELOPMENT &&
+        database.updateDao().loadLaunchAssetForUpdate(update.id) == null
+      ) {
+        logger.warn("Skipping launchable update with no launch asset. Debug info: ${update.debugInfo()}")
+        continue
+      }
       filteredLaunchableUpdates.add(update)
     }
     val manifestFilters = ManifestMetadata.getManifestFilters(database, configuration)

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

@@ -22,6 +22,7 @@ import expo.modules.updates.manifest.ResponsePartHeaderData
 import expo.modules.updates.manifest.ResponsePartInfo
 import expo.modules.updates.manifest.UpdateFactory
 import expo.modules.updates.selectionpolicy.SelectionPolicies
+import expo.modules.updates.utils.AndroidResourceAssetUtils
 import kotlinx.coroutines.suspendCancellableCoroutine
 import okhttp3.Cache
 import okhttp3.Headers
@@ -50,6 +51,7 @@ import kotlin.math.min
 
 private const val PATCH_TEMP_SUFFIX = ".patch"
 private const val PATCHED_TEMP_SUFFIX = ".patched"
+private const val PATCH_BASE_TEMP_SUFFIX = ".base"
 private const val A_IM_HEADER = "A-IM"
 private const val IM_HEADER = "im"
 private const val EXPO_BASE_UPDATE_ID_RESPONSE_HEADER = "expo-base-update-id"
@@ -57,6 +59,8 @@ private const val EXPO_CURRENT_UPDATE_ID_HEADER = "Expo-Current-Update-ID"
 private const val EXPO_REQUESTED_UPDATE_ID_HEADER = "Expo-Requested-Update-ID"
 private const val EXPO_EMBEDDED_UPDATE_ID_HEADER = "Expo-Embedded-Update-ID"
 
+internal typealias EmbeddedAssetExtractor = (AssetEntity, File) -> Unit
+
 /**
  * Utility class that holds all the logic for downloading data and files, such as update manifests
  * and assets, using an instance of [OkHttpClient].
@@ -106,7 +110,8 @@ class FileDownloader(
     progressListener: FileDownloadProgressListener? = null,
     allowPatch: Boolean,
     launchedUpdate: UpdateEntity? = null,
-    requestedUpdate: UpdateEntity? = null
+    requestedUpdate: UpdateEntity? = null,
+    embeddedAssetExtractor: EmbeddedAssetExtractor? = null
   ): FileDownloadResult {
     try {
       val response = downloadData(request, progressListener)
@@ -175,7 +180,8 @@ class FileDownloader(
                 updatesDirectory = updatesDirectory,
                 launchedUpdate = launchedUpdate,
                 requestedUpdate = requestedUpdate,
-                expectedBase64URLEncodedSHA256Hash = expectedBase64URLEncodedSHA256Hash
+                expectedBase64URLEncodedSHA256Hash = expectedBase64URLEncodedSHA256Hash,
+                embeddedAssetExtractor = embeddedAssetExtractor
               )
             }.getOrElse {
               logger.warn(
@@ -293,36 +299,47 @@ class FileDownloader(
     updatesDirectory: File,
     launchedUpdate: UpdateEntity,
     requestedUpdate: UpdateEntity?,
-    expectedBase64URLEncodedSHA256Hash: String?
+    expectedBase64URLEncodedSHA256Hash: String?,
+    embeddedAssetExtractor: EmbeddedAssetExtractor? = null
   ): ByteArray {
     val launchAssetContext = prepareAssetForDiff(
       asset = asset,
       responseBody = responseBody,
+      destination = destination,
       updatesDirectory = updatesDirectory,
-      launchedUpdate = launchedUpdate
+      launchedUpdate = launchedUpdate,
+      embeddedAssetExtractor = embeddedAssetExtractor
     )
 
-    return applyHermesDiff(
-      baseFile = launchAssetContext.baseFile,
-      diffBody = responseBody,
-      destination = destination,
-      expectedBase64URLEncodedSHA256Hash = expectedBase64URLEncodedSHA256Hash,
-      asset = asset,
-      requestedUpdateId = requestedUpdate?.id?.toString()
-    )
+    try {
+      return applyHermesDiff(
+        baseFile = launchAssetContext.baseFile,
+        diffBody = responseBody,
+        destination = destination,
+        expectedBase64URLEncodedSHA256Hash = expectedBase64URLEncodedSHA256Hash,
+        asset = asset,
+        requestedUpdateId = requestedUpdate?.id?.toString()
+      )
+    } finally {
+      if (launchAssetContext.isTemporary) {
+        launchAssetContext.baseFile.delete()
+      }
+    }
   }
 
-  internal data class LaunchAssetContext(val baseFile: File)
+  internal data class LaunchAssetContext(val baseFile: File, val isTemporary: Boolean = false)
 
   @VisibleForTesting
   internal fun prepareAssetForDiff(
     asset: AssetEntity,
     responseBody: ResponseBody,
+    destination: File,
     updatesDirectory: File,
-    launchedUpdate: UpdateEntity
+    launchedUpdate: UpdateEntity,
+    embeddedAssetExtractor: EmbeddedAssetExtractor? = null
   ): LaunchAssetContext {
     return try {
-      preparePatchBaseAsset(asset, updatesDirectory, launchedUpdate)
+      preparePatchBaseAsset(asset, destination, updatesDirectory, launchedUpdate, embeddedAssetExtractor)
     } catch (e: Exception) {
       responseBody.close()
       if (e is IOException) {
@@ -335,8 +352,10 @@ class FileDownloader(
 
   private fun preparePatchBaseAsset(
     asset: AssetEntity,
+    destination: File,
     updatesDirectory: File,
-    launchedUpdate: UpdateEntity
+    launchedUpdate: UpdateEntity,
+    embeddedAssetExtractor: EmbeddedAssetExtractor? = null
   ): LaunchAssetContext {
     if (!asset.isLaunchAsset) {
       throw IOException("Received patch for non-launch asset ${asset.key}")
@@ -350,29 +369,60 @@ class FileDownloader(
     val launchAssetRelativePath = launchAssetEntity.relativePath
       ?: throw IOException("Launch asset for update $currentUpdateId is missing a relative path")
 
-    val baseFile = File(updatesDirectory, launchAssetRelativePath)
+    // BSPatch needs a real path, so an asset inside the APK is extracted first.
+    val isEmbeddedLaunchAsset = AndroidResourceAssetUtils.isAndroidResourceAsset(launchAssetRelativePath)
+    val baseFile = if (isEmbeddedLaunchAsset) {
+      extractEmbeddedPatchBaseAsset(launchAssetEntity, destination, embeddedAssetExtractor)
+    } else {
+      File(updatesDirectory, launchAssetRelativePath)
+    }
     if (!baseFile.exists()) {
       throw IOException("Base asset $baseFile is missing; cannot apply patch")
     }
 
-    val actualBaseHash = try {
-      UpdatesUtils.toBase64Url(UpdatesUtils.sha256(baseFile))
-    } catch (_: Exception) {
-      null
+    val expectedBaseHash = launchAssetEntity.expectedHash
+    if (expectedBaseHash != null) {
+      val actualBaseHash = try {
+        UpdatesUtils.toBase64Url(UpdatesUtils.sha256(baseFile))
+      } catch (_: Exception) {
+        null
+      }
+      if (actualBaseHash != null && expectedBaseHash != actualBaseHash) {
+        logger.warn(
+          "Asset hash mismatch for update $currentUpdateId; expected=$expectedBaseHash actual=$actualBaseHash",
+          UpdatesErrorCode.AssetsFailedToLoad,
+          currentUpdateId.toString(),
+          asset.key
+        )
+        if (isEmbeddedLaunchAsset) {
+          baseFile.delete()
+        }
+        throw IOException("Asset hash mismatch for update $currentUpdateId; expected=$expectedBaseHash actual=$actualBaseHash")
+      }
     }
 
-    val expectedBaseHash = launchAssetEntity.expectedHash
-    if (expectedBaseHash != null && actualBaseHash != null && expectedBaseHash != actualBaseHash) {
-      logger.warn(
-        "Asset hash mismatch for update $currentUpdateId; expected=$expectedBaseHash actual=$actualBaseHash",
-        UpdatesErrorCode.AssetsFailedToLoad,
-        currentUpdateId.toString(),
-        asset.key
-      )
-      throw IOException("Asset hash mismatch for update $currentUpdateId; expected=$expectedBaseHash actual=$actualBaseHash")
+    return LaunchAssetContext(baseFile, isTemporary = isEmbeddedLaunchAsset)
+  }
+
+  @Throws(IOException::class)
+  private fun extractEmbeddedPatchBaseAsset(
+    launchAssetEntity: AssetEntity,
+    destination: File,
+    embeddedAssetExtractor: EmbeddedAssetExtractor?
+  ): File {
+    if (embeddedAssetExtractor == null) {
+      throw IOException("The launch asset lives in the app binary and cannot be extracted without an extractor")
     }
 
-    return LaunchAssetContext(baseFile)
+    val baseFile = File(destination.absolutePath + PATCH_BASE_TEMP_SUFFIX)
+    try {
+      baseFile.parentFile?.mkdirs()
+      embeddedAssetExtractor(launchAssetEntity, baseFile)
+    } catch (e: Exception) {
+      baseFile.delete()
+      throw e as? IOException ?: IOException("Failed to extract the embedded launch asset", e)
+    }
+    return baseFile
   }
 
   @VisibleForTesting
@@ -677,7 +727,8 @@ class FileDownloader(
     extraHeaders: JSONObject,
     launchedUpdate: UpdateEntity?,
     requestedUpdate: UpdateEntity?,
-    assetLoadProgressListener: ((Double) -> Unit)? = null
+    assetLoadProgressListener: ((Double) -> Unit)? = null,
+    embeddedAssetExtractor: EmbeddedAssetExtractor? = null
   ): AssetDownloadResult {
     if (asset.url == null) {
       val message = "Failed to download asset ${asset.key}"
@@ -721,7 +772,8 @@ class FileDownloader(
           assetLoadProgressListener?.let { listener -> { listener.invoke(it) } },
           allowPatch = canApplyPatch,
           launchedUpdate = launchedUpdate,
-          requestedUpdate = requestedUpdate
+          requestedUpdate = requestedUpdate,
+          embeddedAssetExtractor = embeddedAssetExtractor
         )
 
         asset.downloadTime = Date()

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,6 +18,7 @@ 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
@@ -164,21 +166,32 @@ abstract class Loader protected constructor(
       database.updateDao().setUpdateScopeKey(existingUpdateEntity, newUpdateEntity.scopeKey)
     }
 
-    if (existingUpdateEntity != null && existingUpdateEntity.status == UpdateStatus.READY) {
+    // A READY update with no launch asset is not actually ready. Fall through to
+    // downloadAllAssets so its assets are re-registered instead of staying broken forever.
+    if (existingUpdateEntity != null && existingUpdateEntity.status == UpdateStatus.READY &&
+      database.updateDao().loadLaunchAssetForUpdate(existingUpdateEntity.id) != null
+    ) {
       // hooray, we already have this update downloaded and ready to go!
       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)
     }
   }
 
@@ -188,7 +201,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
 
@@ -235,26 +248,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/RemoteLoader.kt

@@ -14,6 +14,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import java.io.File
+import java.io.IOException
 
 data class ProcessSuccessLoaderResult(
   val availableUpdate: UpdateEntity?,
@@ -66,9 +67,28 @@ class RemoteLoader internal constructor(
     embeddedUpdate: UpdateEntity?
   ): FileDownloader.AssetDownloadResult {
     val extraHeaders = FileDownloader.getExtraHeadersForRemoteAssetRequest(launchedUpdate, embeddedUpdate, requestedUpdate)
-    return mFileDownloader.downloadAsset(assetEntity, updatesDirectory, extraHeaders, launchedUpdate, requestedUpdate) { progress ->
-      assetLoadProgressListener(assetEntity, progress)
-    }
+    return mFileDownloader.downloadAsset(
+      asset = assetEntity,
+      destinationDirectory = updatesDirectory,
+      extraHeaders = extraHeaders,
+      launchedUpdate = launchedUpdate,
+      requestedUpdate = requestedUpdate,
+      embeddedAssetExtractor = { launchAsset, destination ->
+        // The stored path is not the APK asset name; resolve it through the embedded manifest by key.
+        val embeddedLaunchAsset = loaderFiles.readEmbeddedUpdate(context, configuration)
+          ?.assetEntityList
+          ?.find { it.key == launchAsset.key }
+          ?: throw IOException("No embedded asset matches launch asset ${launchAsset.key}")
+        val assetName = embeddedLaunchAsset.embeddedAssetFilename
+          ?: throw IOException("Embedded launch asset ${launchAsset.key} has no APK asset filename")
+        context.assets.open(assetName).use { input ->
+          destination.outputStream().use { output -> input.copyTo(output) }
+        }
+      },
+      assetLoadProgressListener = { progress ->
+        assetLoadProgressListener(assetEntity, progress)
+      }
+    )
   }
 
   companion object {

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/ios/EXUpdates/AppLoader/FileDownloader.swift

@@ -84,6 +84,12 @@ public final class FileDownloader {
   private let updatesDirectory: URL
   private let database: UpdatesDatabase
 
+  /// Overridable for testing, where the fixture is not in `updatesBundle`.
+  internal var embeddedLaunchAssetUrl: URL? = updatesBundle.url(
+    forResource: EmbeddedAppLoader.EXUpdatesBareEmbeddedBundleFilename,
+    withExtension: EmbeddedAppLoader.EXUpdatesBareEmbeddedBundleFileType
+  )
+
   public convenience init(
     config: UpdatesConfig,
     logger: UpdatesLogger,
@@ -558,8 +564,7 @@ public final class FileDownloader {
       throw DiffError.assetNotLaunch
     }
 
-    let baseAsset = try resolveLaunchAsset(launchedUpdate: launchedUpdate)
-    let baseFileUrl = try loadAndVerifyAsset(baseAsset)
+    let baseFileUrl = try resolveBaseFileUrl(launchedUpdate: launchedUpdate)
     let requestedUpdateId = requestedUpdate?.updateId.uuidString
 
     return try createPatchedAsset(
@@ -572,6 +577,19 @@ public final class FileDownloader {
     )
   }
 
+  private func resolveBaseFileUrl(launchedUpdate: Update) throws -> URL {
+    if launchedUpdate.status == UpdateStatus.StatusEmbedded {
+      // StatusEmbedded only launches for this binary's embedded update.
+      guard let embeddedLaunchAssetUrl else {
+        throw DiffError.embeddedBaseAssetMissing
+      }
+      return embeddedLaunchAssetUrl
+    }
+
+    let baseAsset = try resolveLaunchAsset(launchedUpdate: launchedUpdate)
+    return try loadAndVerifyAsset(baseAsset)
+  }
+
   private func resolveLaunchAsset(launchedUpdate: Update) throws -> UpdateAsset {
     let currentUpdateId = launchedUpdate.updateId
     var launchAsset: UpdateAsset?
@@ -1239,6 +1257,7 @@ extension FileDownloader {
     case missingHeader(String)
     case invalidHeader(String)
     case launchAssetNotFound
+    case embeddedBaseAssetMissing
     case baseAssetMissing(path: String)
     case failedToReadBaseAsset(cause: Error)
     case failedToWritePatch(cause: Error, path: String)
@@ -1266,6 +1285,8 @@ extension FileDownloader.DiffError: CustomStringConvertible {
       return "Invalid \(header) header"
     case .launchAssetNotFound:
       return "Launch asset not found for current update"
+    case .embeddedBaseAssetMissing:
+      return "Embedded bundle not found in the app binary"
     case let .baseAssetMissing(path):
       return "Base asset is missing at path \(path)"
     case let .failedToReadBaseAsset(cause):

package/ios/EXUpdates/Database/UpdatesDatabase.swift

@@ -160,7 +160,7 @@ public final class UpdatesDatabase: NSObject {
         )
       } catch {
         sqlite3_exec(db, "ROLLBACK;", nil, nil, nil)
-        return
+        throw error
       }
 
       // statements must stay in precisely this order for last_insert_rowid() to work correctly
@@ -170,7 +170,7 @@ public final class UpdatesDatabase: NSObject {
           _ = try execute(sql: updateSql, withArgs: [updateId])
         } catch {
           sqlite3_exec(db, "ROLLBACK;", nil, nil, nil)
-          return
+          throw error
         }
       }
 
@@ -181,7 +181,7 @@ public final class UpdatesDatabase: NSObject {
         _ = try execute(sql: updateInsertSql, withArgs: [updateId])
       } catch {
         sqlite3_exec(db, "ROLLBACK;", nil, nil, nil)
-        return
+        throw error
       }
     }
 
@@ -444,7 +444,23 @@ public final class UpdatesDatabase: NSObject {
     )
 
     let rows = try execute(sql: sql, withArgs: [config.scopeKey])
-    return rows.map { row in
+
+    // A ready row with no launch asset is corrupt (e.g. from an interrupted registration) and
+    // would fail every launch. Demote it for the loader to retry instead of offering it.
+    var launchableRows: [[String: Any?]] = []
+    for row in rows {
+      let status: NSNumber = row.requiredValue(forKey: "status")
+      let launchAssetId: NSNumber? = row.optionalValue(forKey: "launch_asset_id")
+      if status.intValue == UpdateStatus.StatusReady.rawValue && launchAssetId == nil {
+        let updateId: UUID = row.requiredValue(forKey: "id")
+        let demoteSql = "UPDATE updates SET status = ?1 WHERE id = ?2;"
+        _ = try execute(sql: demoteSql, withArgs: [UpdateStatus.StatusPending.rawValue, updateId])
+      } else {
+        launchableRows.append(row)
+      }
+    }
+
+    return launchableRows.map { row in
       update(withRow: row, config: config)
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-updates",
-  "version": "56.0.25",
+  "version": "56.0.27",
   "description": "Fetches and manages remotely-hosted assets and updates to your app's JS bundle.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -60,10 +60,10 @@
     "picomatch": "^4.0.4",
     "ts-node": "^10.9.2",
     "xstate": "^4.37.2",
-    "expo-dev-client": "56.0.25",
-    "expo-module-scripts": "56.0.3",
-    "expo": "56.0.20",
-    "@expo/metro-config": "56.0.18"
+    "@expo/metro-config": "56.0.19",
+    "expo": "56.0.22",
+    "expo-dev-client": "56.0.27",
+    "expo-module-scripts": "56.0.3"
   },
   "peerDependencies": {
     "expo": "*",
@@ -82,7 +82,7 @@
       "./scripts/with-node.sh"
     ]
   },
-  "gitHead": "39f9dc47fb5ddd099a2533dd0ff24be7126a1ed0",
+  "gitHead": "6a613ddc65139388dc1d25ccef2e88721fc66384",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",

package/utils/src/createManifestForBuildAsync.ts

@@ -64,12 +64,14 @@ export async function createManifestForBuildAsync(
         'The hashAssetFiles Metro plugin is not configured. You need to add a metro.config.js to your project that configures Metro to use this plugin. See https://github.com/expo/expo/blob/main/packages/expo-updates/README.md#metroconfigjs for an example.'
       );
     }
-    filterPlatformAssetScales(platform, asset.scales).forEach(function (scale, index) {
+    filterPlatformAssetScales(platform, asset.scales).forEach(function (scale) {
       const baseAssetInfoForManifest = {
         name: asset.name,
         type: asset.type,
         scale,
-        packagerHash: asset.fileHashes[index],
+        // `fileHashes` is parallel to the unfiltered `asset.scales`, so it must be indexed by the
+        // scale's position there rather than by its position in the filtered list.
+        packagerHash: asset.fileHashes[asset.scales.indexOf(scale)],
         subdirectory: asset.httpServerLocation,
       };
       if (platform === 'ios') {