expo-updates 55.0.31 → 55.0.32

package/CHANGELOG.md

@@ -10,6 +10,12 @@
 
 ### 💡 Others
 
+## 55.0.32 — 2026-09-28
+
+### 🐛 Bug fixes
+
+- [iOS] Reuse an embedded asset from the app binary instead of re-downloading it when an update requires the same asset key. ([#49650](https://github.com/expo/expo/pull/49650) by [@alanjhughes](https://github.com/alanjhughes))
+
 ## 55.0.31 — 2026-09-17
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -42,7 +42,7 @@ expoModule {
 }
 
 group = 'host.exp.exponent'
-version = '55.0.31'
+version = '55.0.32'
 
 // 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.31'
+    versionName '55.0.32'
     consumerProguardFiles("proguard-rules.pro")
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 

package/ios/EXUpdates/AppLoader/AppLoader.swift

@@ -49,6 +49,16 @@ open class AppLoader: NSObject {
   private let arrayLock: NSLock = NSLock()
   private let completionQueue: DispatchQueue
 
+  /// Overridable for testing, where the bundle has no `app.manifest`.
+  internal lazy var embeddedUpdate: Update? = EmbeddedAppLoader.embeddedManifest(withConfig: config, database: database)
+
+  /// Overridable for testing, where fixtures live in the test bundle rather than in `updatesBundle`.
+  internal var embeddedAssetsBundle: Bundle = updatesBundle
+
+  /// Whether an asset with no database row may be copied out of the app binary rather than
+  /// downloaded. Only remote loads have anything to reuse.
+  internal var reusesEmbeddedAssets: Bool { true }
+
   public init(
     config: UpdatesConfig,
     logger: UpdatesLogger,
@@ -208,7 +218,13 @@ open class AppLoader: NSObject {
       if let assets = updateManifest.assets(),
         !assets.isEmpty {
         self.assetsToLoad = assets
-        let embeddedUpdate = EmbeddedAppLoader.embeddedManifest(withConfig: self.config, database: self.database)
+        let embeddedUpdate = self.embeddedUpdate
+        let embeddedAssetsByKey = Dictionary(
+          (embeddedUpdate?.assets() ?? []).compactMap { embeddedAsset in
+            embeddedAsset.key.map { ($0, embeddedAsset) }
+          },
+          uniquingKeysWith: { first, _ in first }
+        )
         let requestedUpdate: Update? = {
           if let launchedUpdate = self.launchedUpdate,
             launchedUpdate.updateId == updateManifest.updateId {
@@ -251,7 +267,12 @@ open class AppLoader: NSObject {
               }
             }
           } else {
-            self.downloadAsset(asset, extraHeaders: extraHeaders)
+            FileDownloader.assetFilesQueue.async {
+              if self.copyAssetFromEmbeddedBundleIfPresent(asset, embeddedAssetsByKey: embeddedAssetsByKey) {
+                return
+              }
+              self.downloadAsset(asset, extraHeaders: extraHeaders)
+            }
           }
         }
       } else {
@@ -260,6 +281,60 @@ open class AppLoader: NSObject {
     }
   }
 
+  /**
+   * Satisfies an asset from the embedded update in the app binary rather than downloading it.
+   * Embedded assets have no database row when copying is off, so the lookup above misses them and
+   * a remote update would otherwise re-download bytes that already ship in the app.
+   *
+   * Returns true when it handled the asset. Every failure returns false so the caller downloads it.
+   *
+   * Must be called on `FileDownloader.assetFilesQueue`.
+   */
+  internal func copyAssetFromEmbeddedBundleIfPresent(
+    _ asset: UpdateAsset,
+    embeddedAssetsByKey: [String: UpdateAsset]
+  ) -> Bool {
+    guard reusesEmbeddedAssets else {
+      return false
+    }
+
+    guard let key = asset.key,
+      UpdatesUtils.isSafeFilename(asset.filename),
+      let embeddedAsset = embeddedAssetsByKey[key],
+      embeddedAsset.mainBundleFilename != nil,
+      let bundlePath = UpdatesUtils.path(forBundledAsset: embeddedAsset, in: embeddedAssetsBundle) else {
+      return false
+    }
+
+    guard let data = try? Data(contentsOf: URL(fileURLWithPath: bundlePath), options: .mappedIfSafe) else {
+      logger.warn(message: "AppLoader: could not read embedded asset \(key), downloading it instead")
+      return false
+    }
+
+    // Keys are content-addressed, so a mismatch means the manifest is wrong about what we shipped.
+    if let expectedHash = asset.expectedHash {
+      let actualHash = UpdatesUtils.base64UrlEncodedSHA256WithData(data)
+      if expectedHash != actualHash {
+        logger.warn(
+          message: "AppLoader: embedded asset \(key) hashed to \(actualHash) but the update expects \(expectedHash), downloading it instead"
+        )
+        return false
+      }
+    }
+
+    do {
+      try data.write(to: directory.appendingPathComponent(asset.filename), options: .atomic)
+    } catch {
+      logger.warn(message: "AppLoader: could not copy embedded asset \(key) into the updates directory, downloading it instead")
+      return false
+    }
+
+    DispatchQueue.global().async {
+      self.handleAssetDownload(withData: data, response: nil, asset: asset)
+    }
+    return true
+  }
+
   public func handleAssetDownloadAlreadyExists(_ asset: UpdateAsset) {
     arrayLock.lock()
     assetsToLoad.remove(asset)

package/ios/EXUpdates/AppLoader/EmbeddedAppLoader.swift

@@ -205,6 +205,10 @@ public final class EmbeddedAppLoader: AppLoader {
     }
   }
 
+  /// This loader is already reading the bundle it would copy from, so the copy-enabled path keeps
+  /// resolving files through the launcher as it did before.
+  override internal var reusesEmbeddedAssets: Bool { false }
+
   override public func downloadAsset(_ asset: UpdateAsset, extraHeaders: [String: Any]) {
     FileDownloader.assetFilesQueue.async {
       self.handleAssetDownloadAlreadyExists(asset)

package/ios/EXUpdates/UpdatesUtils.swift

@@ -149,10 +149,14 @@ public final class UpdatesUtils: NSObject {
   }
 
   internal static func path(forBundledAsset asset: UpdateAsset) -> String? {
+    return path(forBundledAsset: asset, in: updatesBundle)
+  }
+
+  internal static func path(forBundledAsset asset: UpdateAsset, in bundle: Bundle) -> String? {
     guard let mainBundleDir = asset.mainBundleDir else {
-      return updatesBundle.path(forResource: asset.mainBundleFilename, ofType: asset.type)
+      return bundle.path(forResource: asset.mainBundleFilename, ofType: asset.type)
     }
-    return updatesBundle.path(forResource: asset.mainBundleFilename, ofType: asset.type, inDirectory: mainBundleDir)
+    return bundle.path(forResource: asset.mainBundleFilename, ofType: asset.type, inDirectory: mainBundleDir)
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-updates",
-  "version": "55.0.31",
+  "version": "55.0.32",
   "description": "Fetches and manages remotely-hosted assets and updates to your app's JS bundle.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -71,5 +71,5 @@
     "react": "*",
     "react-native": "*"
   },
-  "gitHead": "167ec74a43d77e1b61f751440334f9e645f8d2be"
+  "gitHead": "915622ac118d2dc5a30df45cb55f7cfa1a635063"
 }