@hot-updater/react-native 1.0.5 → 1.0.7

package/ios/HotUpdater/Internal/HotUpdater.mm

@@ -9,17 +9,41 @@
 #include <signal.h>
 #include <unistd.h>
 
+#if defined(SWIFT_PACKAGE)
+// Swift Package Manager: the Swift classes, through the protocols they conform
+// to (see HotUpdaterInterface.h).
+#import "HotUpdaterInterface.h"
+typedef NSObject<HotUpdaterImplInterface> HotUpdaterImpl;
+typedef NSObject<HotUpdaterConfigInterface> HotUpdaterConfig;
+#else
 #if __has_include("HotUpdater/HotUpdater-Swift.h")
 #import "HotUpdater/HotUpdater-Swift.h"
 #else
 #import "HotUpdater-Swift.h"
 #endif
 
+static HotUpdaterImpl *HotUpdaterMakeImpl(void)
+{
+  return [[HotUpdaterImpl alloc] init];
+}
+
+static NSString *HotUpdaterAppVersion(void)
+{
+  return [HotUpdaterImpl appVersion];
+}
+
+static HotUpdaterConfig *HotUpdaterSharedConfig(void)
+{
+  return [HotUpdaterConfig shared];
+}
+#endif
+
 @interface HotUpdater (InternalSharedImpl)
 + (HotUpdaterImpl *)sharedImpl;
-+ (NSString *)generateUUIDv7FromTimestamp:(uint64_t)timestampMs;
 @end
 
+extern "C" NSString *HotUpdaterBuildMinBundleId(void);
+
 namespace {
 constexpr size_t kHotUpdaterMaxBundleIdLength = 128;
 const int kHotUpdaterSignals[] = {SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTRAP};
@@ -207,61 +231,11 @@ extern "C" BOOL HotUpdaterPerformRecoveryReload(void)
 
 extern "C" NSString *HotUpdaterGetMinBundleId(void)
 {
-  static NSString *uuid = nil;
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
 #if DEBUG
-    uuid = @"00000000-0000-0000-0000-000000000000";
+  return @"00000000-0000-0000-0000-000000000000";
 #else
-    // Step 1: Use the HOT_UPDATER_MIN_BUNDLE_ID build setting, which the
-    // hot-updater CLI passes to xcodebuild and the Info.plist slot it adds
-    // (`$(HOT_UPDATER_MIN_BUNDLE_ID)`) carries into the app, as Android
-    // takes -PMIN_BUNDLE_ID.
-    NSString *customValue = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"HOT_UPDATER_MIN_BUNDLE_ID"];
-    if ([customValue isKindOfClass:[NSString class]]) {
-      NSString *trimmed = [customValue stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
-      // An unset build setting leaves the slot empty or unexpanded; anything
-      // but a UUID falls back to the compile time below.
-      NSUUID *parsed = trimmed.length > 0 ? [[NSUUID alloc] initWithUUIDString:trimmed] : nil;
-      if (parsed) {
-        uuid = parsed.UUIDString.lowercaseString;
-        RCTLogInfo(@"[HotUpdater.mm] Using MIN_BUNDLE_ID from the HOT_UPDATER_MIN_BUNDLE_ID build setting: %@", uuid);
-        return;
-      }
-      if (trimmed.length > 0 && ![trimmed isEqualToString:@"$(HOT_UPDATER_MIN_BUNDLE_ID)"]) {
-        RCTLogWarn(@"[HotUpdater.mm] Ignoring HOT_UPDATER_MIN_BUNDLE_ID %@: not a UUID", trimmed);
-      }
-    }
-
-    // Step 2: Fall back to the compile time (26-hour subtraction)
-    RCTLogInfo(@"[HotUpdater.mm] No HOT_UPDATER_MIN_BUNDLE_ID build setting, using the compile time");
-
-    NSString *compileDateStr = [NSString stringWithFormat:@"%s %s", __DATE__, __TIME__];
-    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
-
-    // Parse __DATE__ __TIME__ as UTC to ensure consistent timezone handling across all build environments
-    [formatter setTimeZone:[NSTimeZone timeZoneWithName:@"UTC"]];
-    [formatter setLocale:[[NSLocale alloc] initWithLocaleIdentifier:@"en_US_POSIX"]];
-    [formatter setDateFormat:@"MMM d yyyy HH:mm:ss"];
-    NSDate *buildDate = [formatter dateFromString:compileDateStr];
-    if (!buildDate) {
-      RCTLogWarn(@"[HotUpdater.mm] Could not parse build date: %@", compileDateStr);
-      uuid = @"00000000-0000-0000-0000-000000000000";
-      return;
-    }
-
-    // Subtract 26 hours (93600 seconds) to ensure MIN_BUNDLE_ID is always in the past
-    // This guarantees that uuidv7-based bundleIds (generated at runtime) will always be newer than MIN_BUNDLE_ID
-    // Why 26 hours? Global timezone range spans from UTC-12 to UTC+14 (total 26 hours)
-    // By subtracting 26 hours, MIN_BUNDLE_ID becomes a safe "past timestamp" regardless of build timezone
-    // Example: Build at 15:00 in any timezone -> parse as 15:00 UTC -> subtract 26h -> 13:00 UTC (previous day)
-    NSTimeInterval adjustedTimestamp = [buildDate timeIntervalSince1970] - 93600.0;
-    uint64_t buildTimestampMs = (uint64_t)(adjustedTimestamp * 1000.0);
-
-    uuid = [HotUpdater generateUUIDv7FromTimestamp:buildTimestampMs];
+  return HotUpdaterBuildMinBundleId();
 #endif
-  });
-  return uuid;
 }
 
 extern "C" void *HotUpdaterCopyMinBundleId(void)
@@ -405,54 +379,22 @@ RCT_EXPORT_MODULE();
     static HotUpdaterImpl *_sharedImpl = nil;
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
-        _sharedImpl = [[HotUpdaterImpl alloc] init];
+        _sharedImpl = HotUpdaterMakeImpl();
     });
     return _sharedImpl;
 }
 
 #pragma mark - React Native Constants (Keep getMinBundleId, delegate others)
 
-// Returns the minimum bundle ID string, either from Info.plist or generated from build timestamp
+// Returns the bundle ID of the bundle this build ships (MIN_BUNDLE_ID)
 - (NSString *)getMinBundleId {
      return HotUpdaterGetMinBundleId();
 }
 
-// Helper method: Generate UUID v7 from timestamp (milliseconds)
-+ (NSString *)generateUUIDv7FromTimestamp:(uint64_t)timestampMs {
-    unsigned char bytes[16];
-
-    // UUID v7 format: timestamp_ms (48 bits) + ver (4 bits) + random (12 bits) + variant (2 bits) + random (62 bits)
-    bytes[0] = (timestampMs >> 40) & 0xFF;
-    bytes[1] = (timestampMs >> 32) & 0xFF;
-    bytes[2] = (timestampMs >> 24) & 0xFF;
-    bytes[3] = (timestampMs >> 16) & 0xFF;
-    bytes[4] = (timestampMs >> 8) & 0xFF;
-    bytes[5] = timestampMs & 0xFF;
-
-    // Version 7
-    bytes[6] = 0x70;
-    bytes[7] = 0x00;
-
-    // Variant bits (10xxxxxx)
-    bytes[8] = 0x80;
-    bytes[9] = 0x00;
-
-    // Remaining bytes (zeros for deterministic MIN_BUNDLE_ID)
-    for (int i = 10; i < 16; i++) {
-        bytes[i] = 0x00;
-    }
-
-    return [NSString stringWithFormat:
-            @"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
-            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
-            bytes[8], bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]];
-}
-
-
 - (NSDictionary *)_buildConstantsDictionary {
     return @{
         @"MIN_BUNDLE_ID": [self getMinBundleId] ?: [NSNull null],
-        @"APP_VERSION": [HotUpdaterImpl appVersion] ?: [NSNull null],
+        @"APP_VERSION": HotUpdaterAppVersion() ?: [NSNull null],
         @"CHANNEL": [[HotUpdater sharedImpl] getChannel] ?: [NSNull null],
         @"DEFAULT_CHANNEL": [[HotUpdater sharedImpl] getDefaultChannel] ?: [NSNull null],
         @"FINGERPRINT_HASH": [[HotUpdater sharedImpl] getFingerprintHash] ?: [NSNull null]
@@ -484,7 +426,7 @@ RCT_EXPORT_MODULE();
                            publicKey:(NSString *)publicKey
                              channel:(NSString *)channel
                         isolationKey:(NSString *)isolationKey {
-    HotUpdaterConfig *config = [HotUpdaterConfig shared];
+    HotUpdaterConfig *config = HotUpdaterSharedConfig();
     [config configureWithFingerprintHash:fingerprintHash publicKey:publicKey channel:channel isolationKey:isolationKey];
 }
 
@@ -590,11 +532,61 @@ RCT_EXPORT_MODULE();
     if (params.selection()) {
         paramDict[@"selection"] = params.selection();
     }
+    // Legacy: what JavaScript from the first artifact protocol v2 SDK sends.
+    if (params.filesUrl()) {
+        paramDict[@"filesUrl"] = params.filesUrl();
+    }
+    if (params.requestHeaders()) {
+        paramDict[@"requestHeaders"] = params.requestHeaders();
+    }
+    if (params.requestTimeout().has_value()) {
+        paramDict[@"requestTimeout"] = @(params.requestTimeout().value());
+    }
 
     HotUpdaterImpl *impl = [HotUpdater sharedImpl];
     [impl updateBundle:paramDict resolver:resolve rejecter:reject];
 }
 
+- (void)installArtifact:(JS::NativeHotUpdater::InstallArtifactParams &)params
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+    NSLog(@"[HotUpdater.mm] installArtifact called.");
+    NSMutableDictionary *paramDict = [NSMutableDictionary dictionary];
+    if (params.bundleId()) {
+        paramDict[@"bundleId"] = params.bundleId();
+    }
+    if (params.manifestUrl()) {
+        paramDict[@"manifestUrl"] = params.manifestUrl();
+    }
+    if (params.manifestFileHash()) {
+        paramDict[@"manifestFileHash"] = params.manifestFileHash();
+    }
+    if (params.archiveUrl()) {
+        paramDict[@"archiveUrl"] = params.archiveUrl();
+    }
+    if (params.patch()) {
+        paramDict[@"patch"] = params.patch();
+    }
+    if (params.filesUrl()) {
+        paramDict[@"filesUrl"] = params.filesUrl();
+    }
+    if (params.requestHeaders()) {
+        paramDict[@"requestHeaders"] = params.requestHeaders();
+    }
+    if (params.requestTimeout().has_value()) {
+        paramDict[@"requestTimeout"] = @(params.requestTimeout().value());
+    }
+    if (params.channel()) {
+        paramDict[@"channel"] = params.channel();
+    }
+    if (params.selection()) {
+        paramDict[@"selection"] = params.selection();
+    }
+
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    [impl installArtifact:paramDict resolver:resolve rejecter:reject];
+}
+
 - (NSNumber *)acceptReleaseCatalog:(NSDictionary *)params {
     return @([[HotUpdater sharedImpl] acceptReleaseCatalog:params]);
 }
@@ -710,7 +702,7 @@ RCT_EXPORT_MODULE();
     HotUpdaterImpl *impl = [HotUpdater sharedImpl];
     return facebook::react::typedConstants<JS::NativeHotUpdater::Constants::Builder>({
         .MIN_BUNDLE_ID = [self getMinBundleId],
-        .APP_VERSION = [HotUpdaterImpl appVersion],
+        .APP_VERSION = HotUpdaterAppVersion(),
         .CHANNEL = [impl getChannel],
         .DEFAULT_CHANNEL = [impl getDefaultChannel],
         .FINGERPRINT_HASH = [impl getFingerprintHash],
@@ -760,6 +752,14 @@ RCT_EXPORT_METHOD(updateBundle:(NSDictionary *)params
     [impl updateBundle:params resolver:resolve rejecter:reject];
 }
 
+RCT_EXPORT_METHOD(installArtifact:(NSDictionary *)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    NSLog(@"[HotUpdater.mm] installArtifact called.");
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    [impl installArtifact:params resolver:resolve rejecter:reject];
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(acceptReleaseCatalog:(NSDictionary *)params) {
     return @([[HotUpdater sharedImpl] acceptReleaseCatalog:params]);
 }

package/ios/HotUpdater/Internal/HotUpdaterImpl.swift

@@ -260,10 +260,52 @@ private func hotUpdaterGetMinBundleId() -> String {
      * @param reject Promise reject callback; download and install failures
      *   carry `stage`, `reason`, and their details in the error's userInfo
      */
-    public func updateBundle(_ params: NSDictionary?,
+    public func updateBundle(_ params: [AnyHashable: Any]?,
                                          resolver resolve: @escaping RCTPromiseResolveBlock,
                                          rejecter reject: @escaping RCTPromiseRejectBlock) {
-        
+        // Legacy: artifact protocol v1, where every file comes with its URL.
+        // JavaScript from the first protocol v2 SDK also sends `filesUrl`
+        // here, with only the Hermes patch in `assets`; its OTA Bundles must
+        // still install.
+        stage(params, resolver: resolve, rejecter: reject) { data, reject in
+            switch Self.parseFileResolver(data, required: false) {
+            case .failure(let error):
+                reject("INVALID_FILE_URL", error.localizedDescription, error)
+                return nil
+            case .success(let fileResolver):
+                return Self.parseAssets(data, requireFileHash: fileResolver == nil, rejecter: reject)
+                    .map { ($0, fileResolver) }
+            }
+        }
+    }
+
+    /**
+     * Installs a Bundle over artifact protocol v2: native asks `filesUrl` for
+     * the files it downloads one by one, after reusing local files and
+     * choosing the archive.
+     * @param params Dictionary with bundleId, manifest, `filesUrl`, and the
+     *   optional Hermes `patch` with its `assetPath`
+     * @param resolve Promise resolve callback, called with the staged bundle's
+     *   `{ delivery, patchFallback }`
+     * @param reject Promise reject callback, as for `updateBundle`
+     */
+    public func installArtifact(_ params: [AnyHashable: Any]?,
+                                resolver resolve: @escaping RCTPromiseResolveBlock,
+                                rejecter reject: @escaping RCTPromiseRejectBlock) {
+        stage(params, resolver: resolve, rejecter: reject) { data, reject in
+            Self.parseArtifactInstall(data, rejecter: reject)
+        }
+    }
+
+    private typealias StagePlan = (assets: [String: ChangedAssetDescriptor], fileResolver: ArtifactFileResolver?)
+
+    /// Validates the common parameters, then stages the Bundle with the
+    /// assets and file resolver `plan` returns; `plan` rejects and returns nil
+    /// when its own parameters are invalid.
+    private func stage(_ params: [AnyHashable: Any]?,
+                       resolver resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock,
+                       plan: ([AnyHashable: Any], RCTPromiseRejectBlock) -> StagePlan?) {
         do {
             // Validate parameters (this runs on calling thread - typically JS thread)
             guard let data = params else {
@@ -309,54 +351,9 @@ private func hotUpdaterGetMinBundleId() -> String {
             } else {
                 archiveUrl = nil
             }
-            guard let assetsPayload = data["assets"] as? [String: [String: Any]] else {
-                let error = UpdateFailure.invalidResponse.with(resource: .manifest)
-                    .error(description: "Missing manifest assets")
-                reject("INVALID_MANIFEST", error.localizedDescription, error)
+            guard let planned = plan(data, reject) else {
                 return
             }
-            let assets = assetsPayload.reduce(into: [String: ChangedAssetDescriptor]()) { partialResult, entry in
-                guard let fileHash = entry.value["fileHash"] as? String,
-                      !fileHash.isEmpty
-                else {
-                    return
-                }
-
-                let patchPayload = entry.value["patch"] as? [String: Any]
-                let patch = patchPayload.flatMap { payload -> BsdiffPatchDescriptor? in
-                    guard let algorithm = payload["algorithm"] as? String,
-                          let baseBundleId = payload["baseBundleId"] as? String,
-                          let baseFileHash = payload["baseFileHash"] as? String,
-                          let patchFileHash = payload["patchFileHash"] as? String,
-                          let patchUrlString = payload["patchUrl"] as? String,
-                          let patchUrl = URL(string: patchUrlString)
-                    else {
-                        return nil
-                    }
-
-                    return BsdiffPatchDescriptor(
-                        algorithm: algorithm,
-                        baseBundleId: baseBundleId,
-                        baseFileHash: baseFileHash,
-                        patchFileHash: patchFileHash,
-                        patchUrl: patchUrl,
-                        byteSize: Self.parseSafeByteSize(payload["byteSize"])
-                    )
-                }
-                let filePayload = entry.value["file"] as? [String: Any]
-                let fileUrl = (filePayload?["url"] as? String).flatMap { URL(string: $0) }
-                let fileCompression = filePayload?["compression"] as? String
-                guard fileUrl != nil || patch != nil else {
-                    return
-                }
-
-                partialResult[entry.key] = ChangedAssetDescriptor(
-                    fileUrl: fileUrl,
-                    fileHash: fileHash,
-                    fileCompression: fileCompression,
-                    patch: patch
-                )
-            }
             let selection = (data["selection"] as? [String: Any]).flatMap(Self.parseSelection)
             if let selection, !bundleStorage.stageReleaseSelection(selection) {
                 // Not an update failure, so the rejection carries no stage or reason.
@@ -371,7 +368,7 @@ private func hotUpdaterGetMinBundleId() -> String {
             NSLog("[HotUpdaterImpl] updateBundle called with bundleId: \(bundleId), manifestUrl: \(manifestUrl.absoluteString)")
 
             // Heavy work is delegated to bundle storage service with safe error handling
-            bundleStorage.updateBundle(bundleId: bundleId, manifestUrl: manifestUrl, manifestFileHash: manifestFileHash, archiveUrl: archiveUrl, assets: assets, progressHandler: { payload in
+            bundleStorage.updateBundle(bundleId: bundleId, manifestUrl: manifestUrl, manifestFileHash: manifestFileHash, archiveUrl: archiveUrl, assets: planned.assets, fileResolver: planned.fileResolver, progressHandler: { payload in
                 DispatchQueue.main.async {
                     NotificationCenter.default.post(
                         name: .updateProgressDidChange,
@@ -429,6 +426,111 @@ private func hotUpdaterGetMinBundleId() -> String {
         }
     }
 
+    /// Every changed file with its hash and URL or Hermes patch; without
+    /// `requireFileHash`, also entries that hold only the Hermes patch.
+    private static func parseAssets(_ data: [AnyHashable: Any],
+                                    requireFileHash: Bool,
+                                    rejecter reject: RCTPromiseRejectBlock) -> [String: ChangedAssetDescriptor]? {
+        guard let assetsPayload = data["assets"] as? [String: [String: Any]] else {
+            let error = UpdateFailure.invalidResponse.with(resource: .manifest)
+                .error(description: "Missing manifest assets")
+            reject("INVALID_MANIFEST", error.localizedDescription, error)
+            return nil
+        }
+        return assetsPayload.reduce(into: [String: ChangedAssetDescriptor]()) { partialResult, entry in
+            let fileHash = entry.value["fileHash"] as? String ?? ""
+            guard !fileHash.isEmpty || !requireFileHash else {
+                return
+            }
+
+            let patch = (entry.value["patch"] as? [String: Any]).flatMap(parsePatch)
+            let filePayload = entry.value["file"] as? [String: Any]
+            let fileUrl = (filePayload?["url"] as? String).flatMap { URL(string: $0) }
+            let fileCompression = filePayload?["compression"] as? String
+            guard fileUrl != nil || patch != nil,
+                  !fileHash.isEmpty || fileUrl == nil else {
+                return
+            }
+
+            partialResult[entry.key] = ChangedAssetDescriptor(
+                fileUrl: fileUrl,
+                fileHash: fileHash,
+                fileCompression: fileCompression,
+                patch: patch
+            )
+        }
+    }
+
+    /// The resolver that asks `filesUrl` for the files native downloads one
+    /// by one, with the update check's headers and timeout; nil when
+    /// `filesUrl` is missing and not `required`.
+    private static func parseFileResolver(_ data: [AnyHashable: Any],
+                                          required: Bool) -> Result<ArtifactFileResolver?, NSError> {
+        let filesUrlString = data["filesUrl"] as? String ?? ""
+        if filesUrlString.isEmpty && !required {
+            return .success(nil)
+        }
+        guard !filesUrlString.isEmpty, let filesUrl = URL(string: filesUrlString) else {
+            return .failure(UpdateFailure.invalidResponse.with(resource: .file).error(
+                description: "Invalid 'filesUrl' provided: \(filesUrlString)"
+            ))
+        }
+        // The update check's headers, which the artifact files request repeats.
+        let headers = (data["requestHeaders"] as? [String: Any] ?? [:])
+            .compactMapValues { $0 as? String }
+        let timeout = (data["requestTimeout"] as? NSNumber).map { $0.doubleValue / 1000 }
+            .flatMap { $0 > 0 ? $0 : nil } ?? HTTPArtifactFileResolver.defaultTimeout
+        return .success(HTTPArtifactFileResolver(filesUrl: filesUrl, headers: headers, timeout: timeout))
+    }
+
+    /// Artifact protocol v2: the Hermes patch as the only planned asset, and
+    /// the resolver that asks `filesUrl` for the files native downloads one
+    /// by one.
+    private static func parseArtifactInstall(_ data: [AnyHashable: Any],
+                                             rejecter reject: RCTPromiseRejectBlock) -> StagePlan? {
+        let fileResolver: ArtifactFileResolver?
+        switch parseFileResolver(data, required: true) {
+        case .failure(let error):
+            reject("INVALID_FILE_URL", error.localizedDescription, error)
+            return nil
+        case .success(let resolver):
+            fileResolver = resolver
+        }
+        var assets: [String: ChangedAssetDescriptor] = [:]
+        if let patchPayload = data["patch"] as? [String: Any],
+           let assetPath = patchPayload["assetPath"] as? String,
+           let patch = parsePatch(patchPayload) {
+            assets[assetPath] = ChangedAssetDescriptor(
+                fileUrl: nil,
+                fileHash: "",
+                fileCompression: nil,
+                patch: patch
+            )
+        }
+        return (assets, fileResolver)
+    }
+
+    private static func parsePatch(_ payload: [String: Any]) -> BsdiffPatchDescriptor? {
+        guard let algorithm = payload["algorithm"] as? String,
+              let baseBundleId = payload["baseBundleId"] as? String,
+              let baseFileHash = payload["baseFileHash"] as? String,
+              let patchFileHash = payload["patchFileHash"] as? String,
+              let patchUrlString = payload["patchUrl"] as? String,
+              let patchUrl = URL(string: patchUrlString)
+        else {
+            return nil
+        }
+
+        return BsdiffPatchDescriptor(
+            algorithm: algorithm,
+            baseBundleId: baseBundleId,
+            baseFileHash: baseFileHash,
+            patchFileHash: patchFileHash,
+            patchUrl: patchUrl,
+            byteSize: parseSafeByteSize(payload["byteSize"])
+        )
+    }
+
     private static func parseSelection(_ data: [String: Any]) -> PersistedSelection? {
         guard let kind = data["kind"] as? String,
               let bundleId = data["bundleId"] as? String,
@@ -448,7 +550,7 @@ private func hotUpdaterGetMinBundleId() -> String {
         )
     }
 
-    public func acceptReleaseCatalog(_ params: NSDictionary?) -> Bool {
+    public func acceptReleaseCatalog(_ params: [AnyHashable: Any]?) -> Bool {
         guard let data = params as? [String: Any],
               let catalogId = data["catalogId"] as? String,
               let scopeKey = data["scopeKey"] as? String,
@@ -507,7 +609,7 @@ private func hotUpdaterGetMinBundleId() -> String {
         }
     }
 
-    public func isReleaseSelectionCurrent(_ params: NSDictionary?) -> Bool {
+    public func isReleaseSelectionCurrent(_ params: [AnyHashable: Any]?) -> Bool {
         guard let data = params as? [String: Any],
               let catalogId = data["catalogId"] as? String,
               let scopeKey = data["scopeKey"] as? String,
@@ -528,7 +630,7 @@ private func hotUpdaterGetMinBundleId() -> String {
     }
 
     public func commitReleaseSelection(
-        _ params: NSDictionary?,
+        _ params: [AnyHashable: Any]?,
         resolver resolve: @escaping RCTPromiseResolveBlock,
         rejecter reject: @escaping RCTPromiseRejectBlock
     ) {

package/ios/HotUpdater/Internal/HotUpdaterInterface.swift

@@ -0,0 +1,26 @@
+#if SWIFT_PACKAGE
+import Foundation
+import HotUpdaterInterface
+
+// Swift Package Manager only: the Objective-C++ module reaches these classes
+// through the protocols in HotUpdaterInterface.h, and these conformances make
+// the compiler check that the classes still match them.
+extension HotUpdaterImpl: HotUpdaterImplInterface {}
+
+extension HotUpdaterConfig: HotUpdaterConfigInterface {}
+
+@_cdecl("HotUpdaterMakeImpl")
+public func hotUpdaterMakeImpl() -> HotUpdaterImplInterface {
+    HotUpdaterImpl()
+}
+
+@_cdecl("HotUpdaterAppVersion")
+public func hotUpdaterAppVersion() -> NSString? {
+    HotUpdaterImpl.appVersion as NSString?
+}
+
+@_cdecl("HotUpdaterSharedConfig")
+public func hotUpdaterSharedConfig() -> HotUpdaterConfigInterface {
+    HotUpdaterConfig.shared
+}
+#endif

package/ios/HotUpdater/Internal/HotUpdaterMinBundleId.m

@@ -0,0 +1,10 @@
+#import <Foundation/Foundation.h>
+
+// Generated before every compile by ios/scripts/generate-min-bundle-id.zsh,
+// so this file is the only one rebuilt when the value changes.
+#import "HotUpdaterBuildMinBundleId.h"
+
+NSString *HotUpdaterBuildMinBundleId(void)
+{
+  return @HOT_UPDATER_BUILD_MIN_BUNDLE_ID;
+}

package/ios/HotUpdater/Package.swift

@@ -0,0 +1,88 @@
+// swift-tools-version: 5.10
+import PackageDescription
+
+let coreSources = [
+    "ArtifactFileResolver.swift",
+    "FileUtilities.swift",
+    "BrotliFileDecompressor.swift",
+    "TarArchiveExtractor.swift",
+    "BundleFileStorageService.swift",
+    "BuiltInAssetResolver.swift",
+    "BundleMetadata.swift",
+    "FileManagerService.swift",
+    "HashUtils.swift",
+    "HotUpdaterConfig.swift",
+    "KeyValueStorageService.swift",
+    "NotificationExtension.swift",
+    "ReleaseCatalogCacheService.swift",
+    "SignatureVerifier.swift",
+    "UpdateFailure.swift",
+    "URLSessionDownloadService.swift",
+    "VersionedPreferencesService.swift",
+]
+
+let coreExcludedFiles = [
+    "BsdiffPatchBridge.h",
+    "BsdiffPatchBridge.mm",
+    "CohortService.swift",
+    "HotUpdater-Bridging-Header.h",
+    "HotUpdater.mm",
+    "HotUpdaterImpl.swift",
+    "HotUpdaterInterface.swift",
+    "HotUpdaterMinBundleId.m",
+]
+
+let bsdiffPatchBridgeExcludedFiles =
+    coreSources + coreExcludedFiles.filter {
+        $0 != "BsdiffPatchBridge.h" && $0 != "BsdiffPatchBridge.mm"
+    }
+
+let package = Package(
+    name: "HotUpdater",
+    platforms: [
+        .iOS(.v13),
+        .macOS(.v10_15)
+    ],
+    products: [
+        .library(
+            name: "HotUpdaterCore",
+            targets: ["HotUpdaterCore"]
+        )
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "HotUpdaterRecovery",
+            path: "Recovery",
+            exclude: ["HotUpdaterRecoveryHooks.mm"],
+            sources: ["HotUpdaterRecovery.mm"],
+            publicHeadersPath: ".",
+            cxxSettings: [.define("RCT_NEW_ARCH_ENABLED")]
+        ),
+        .target(
+            name: "HotUpdaterBsdiffPatch",
+            path: "Internal",
+            exclude: bsdiffPatchBridgeExcludedFiles,
+            sources: ["BsdiffPatchBridge.mm"],
+            publicHeadersPath: ".",
+            linkerSettings: [
+                .linkedFramework("Foundation"),
+                .linkedLibrary("bz2"),
+            ]
+        ),
+        // React Native's full native module cannot be built through SPM yet,
+        // but the pure-Swift update core can be.
+        .target(
+            name: "HotUpdaterCore",
+            dependencies: ["HotUpdaterBsdiffPatch"],
+            path: "Internal",
+            exclude: coreExcludedFiles,
+            sources: coreSources
+        ),
+        .testTarget(
+            name: "HotUpdaterTest",
+            dependencies: ["HotUpdaterCore", "HotUpdaterRecovery"],
+            path: "Test"
+        ),
+    ]
+) 

package/ios/Plugins/HotUpdaterMinBundleIdPlugin/HotUpdaterMinBundleIdPlugin.swift

@@ -0,0 +1,28 @@
+import Foundation
+import PackagePlugin
+
+// Runs ios/scripts/generate-min-bundle-id.zsh before every build of the target,
+// the SwiftPM counterpart of the podspec's script phase. The script writes a
+// Swift file defining HotUpdaterBuildMinBundleId(), which HotUpdater.mm calls.
+@main
+struct HotUpdaterMinBundleIdPlugin: BuildToolPlugin {
+    func createBuildCommands(context: PluginContext, target: Target) throws -> [Command] {
+        let script = context.package.directoryURL
+            .appending(path: "ios/scripts/generate-min-bundle-id.zsh")
+        let outputDirectory = context.pluginWorkDirectoryURL
+            .appending(path: "MinBundleId")
+        var environment: [String: String] = [:]
+        if let minBundleId = ProcessInfo.processInfo.environment["HOT_UPDATER_MIN_BUNDLE_ID"] {
+            environment["HOT_UPDATER_MIN_BUNDLE_ID"] = minBundleId
+        }
+        return [
+            .prebuildCommand(
+                displayName: "[HotUpdater] Generate MIN_BUNDLE_ID",
+                executable: URL(filePath: "/bin/zsh"),
+                arguments: [script.path(percentEncoded: false), "--swift", outputDirectory.path(percentEncoded: false)],
+                environment: environment,
+                outputFilesDirectory: outputDirectory
+            ),
+        ]
+    }
+}