@hot-updater/react-native 0.28.0 → 0.29.0

package/ios/HotUpdater/Internal/BundleFileStorageService.swift

@@ -1,5 +1,7 @@
 import Foundation
 
+public typealias ManifestAssets = [String: Any]
+
 public enum BundleStorageError: Error, CustomNSError {
     case directoryCreationFailed
     case downloadFailed(Error)
@@ -54,9 +56,9 @@ public enum BundleStorageError: Error, CustomNSError {
             userInfo[NSLocalizedRecoverySuggestionErrorKey] = "The download was interrupted. Check network connection and try again"
 
         case .extractionFormatError(let underlyingError):
-            userInfo[NSLocalizedDescriptionKey] = "Invalid or corrupted bundle archive format"
+            userInfo[NSLocalizedDescriptionKey] = "The downloaded bundle file is not a valid compressed archive"
             userInfo[NSUnderlyingErrorKey] = underlyingError
-            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "The bundle archive may be corrupted or in an unsupported format. Try downloading again"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "The downloaded file is not a supported bundle archive. Try downloading again"
 
         case .invalidBundle:
             userInfo[NSLocalizedDescriptionKey] = "Bundle missing required platform files (index.ios.bundle or main.jsbundle)"
@@ -120,6 +122,18 @@ public protocol BundleStorageService {
      */
     func getBaseURL() -> String
 
+    /**
+     * Gets the current active bundle ID from bundle storage.
+     * Reads manifest.json first and falls back to older metadata when needed.
+     */
+    func getBundleId() -> String?
+
+    /**
+     * Gets the current manifest from bundle storage.
+     * Returns an empty object when manifest.json is missing or invalid.
+     */
+    func getManifest() -> ManifestAssets
+
     /**
      * Restores the original bundle and clears downloaded bundle state.
      */
@@ -127,6 +141,12 @@ public protocol BundleStorageService {
 }
 
 class BundleFileStorageService: BundleStorageService {
+    private struct ActiveBundleMetadataSnapshot {
+        let activeBundleId: String
+        let bundleId: String?
+        let manifest: ManifestAssets
+    }
+
     private let fileSystem: FileSystemService
     private let downloadService: DownloadService
     private let decompressService: DecompressService
@@ -141,6 +161,8 @@ class BundleFileStorageService: BundleStorageService {
     private var activeTasks: [URLSessionTask] = []
 
     private var currentLaunchReport: LaunchReport?
+    private let activeBundleMetadataLock = NSLock()
+    private var activeBundleMetadataSnapshot: ActiveBundleMetadataSnapshot?
 
     public init(fileSystem: FileSystemService,
                 downloadService: DownloadService,
@@ -252,6 +274,125 @@ class BundleFileStorageService: BundleStorageService {
         return metadata.stableBundleId
     }
 
+    private func getActiveBundleId() -> String? {
+        let metadata = loadMetadataOrNull()
+
+        if let stagingBundleId = metadata?.stagingBundleId {
+            return stagingBundleId
+        }
+
+        if let stableBundleId = metadata?.stableBundleId {
+            return stableBundleId
+        }
+
+        return getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent
+    }
+
+    private func withActiveBundleMetadataLock<T>(_ body: () -> T) -> T {
+        activeBundleMetadataLock.lock()
+        defer { activeBundleMetadataLock.unlock() }
+        return body()
+    }
+
+    private func clearActiveBundleMetadataSnapshot() {
+        withActiveBundleMetadataLock {
+            activeBundleMetadataSnapshot = nil
+        }
+    }
+
+    private func getActiveBundleMetadataSnapshot() -> ActiveBundleMetadataSnapshot? {
+        guard let activeBundleId = getActiveBundleId(),
+              case .success(let storeDir) = bundleStoreDir() else {
+            clearActiveBundleMetadataSnapshot()
+            return nil
+        }
+
+        if let snapshot = withActiveBundleMetadataLock({
+            activeBundleMetadataSnapshot?.activeBundleId == activeBundleId
+                ? activeBundleMetadataSnapshot
+                : nil
+        }) {
+            return snapshot
+        }
+
+        let bundleDir = (storeDir as NSString).appendingPathComponent(activeBundleId)
+        guard fileSystem.fileExists(atPath: bundleDir) else {
+            clearActiveBundleMetadataSnapshot()
+            return nil
+        }
+
+        let snapshot = resolveActiveBundleMetadataSnapshot(
+            activeBundleId: activeBundleId,
+            bundleDirectory: bundleDir
+        )
+        return withActiveBundleMetadataLock {
+            activeBundleMetadataSnapshot = snapshot
+            return snapshot
+        }
+    }
+
+    private func resolveActiveBundleMetadataSnapshot(
+        activeBundleId: String,
+        bundleDirectory: String
+    ) -> ActiveBundleMetadataSnapshot {
+        let manifest = readManifest(in: bundleDirectory) ?? [:]
+        let manifestBundleId =
+            (manifest["bundleId"] as? String)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        let resolvedBundleId =
+            (manifestBundleId?.isEmpty == false ? manifestBundleId : nil) ??
+            readCompatibilityBundleId(in: bundleDirectory)
+
+        return ActiveBundleMetadataSnapshot(
+            activeBundleId: activeBundleId,
+            bundleId: resolvedBundleId,
+            manifest: manifest
+        )
+    }
+
+    private func readCompatibilityBundleId(in bundleDirectory: String) -> String? {
+        let compatibilityBundleIdPath = (bundleDirectory as NSString)
+            .appendingPathComponent(compatibilityBundleIdFilename())
+        if fileSystem.fileExists(atPath: compatibilityBundleIdPath) {
+            do {
+                let compatibilityBundleId = try String(
+                    contentsOfFile: compatibilityBundleIdPath,
+                    encoding: .utf8
+                )
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+
+                if !compatibilityBundleId.isEmpty {
+                    return compatibilityBundleId
+                }
+            } catch {
+                NSLog(
+                    "[BundleStorage] Failed to read compatibility bundle metadata at \(compatibilityBundleIdPath): \(error.localizedDescription)"
+                )
+            }
+        }
+
+        return nil
+    }
+
+    private func compatibilityBundleIdFilename() -> String {
+        "BUNDLE_ID"
+    }
+
+    private func readManifest(in bundleDirectory: String) -> [String: Any]? {
+        let manifestPath = (bundleDirectory as NSString).appendingPathComponent("manifest.json")
+        guard fileSystem.fileExists(atPath: manifestPath) else {
+            return nil
+        }
+
+        do {
+            let manifestData = try Data(contentsOf: URL(fileURLWithPath: manifestPath))
+            return try JSONSerialization.jsonObject(with: manifestData) as? [String: Any]
+        } catch {
+            NSLog("[BundleStorage] Failed to read manifest at \(manifestPath): \(error.localizedDescription)")
+            return nil
+        }
+    }
+
     /**
      * Checks if isolationKey has changed and cleans up old bundles if needed.
      * This handles migration when isolationKey format changes.
@@ -598,6 +739,7 @@ class BundleFileStorageService: BundleStorageService {
         do {
             NSLog("[BundleStorage] Setting bundle URL to: \(localPath ?? "nil")")
             try self.preferences.setItem(localPath, forKey: "HotUpdaterBundleURL")
+            clearActiveBundleMetadataSnapshot()
             return .success(())
         } catch let error {
             return .failure(error)
@@ -1171,35 +1313,7 @@ class BundleFileStorageService: BundleStorageService {
      */
     func getBaseURL() -> String {
         do {
-            let metadata = loadMetadataOrNull()
-            let activeBundleId: String?
-
-            // Prefer the current staging bundle regardless of verification state.
-            if let staging = metadata?.stagingBundleId {
-                activeBundleId = staging
-            } else if let stable = metadata?.stableBundleId {
-                activeBundleId = stable
-            } else {
-                // Fall back to current bundle ID from preferences
-                if let savedURL = try preferences.getItem(forKey: "HotUpdaterBundleURL") {
-                    // Extract bundle ID from path like "bundle-store/abc123/index.ios.bundle"
-                    if let range = savedURL.range(of: "bundle-store/([^/]+)/", options: .regularExpression) {
-                        let match = savedURL[range]
-                        let components = match.split(separator: "/")
-                        if components.count >= 2 {
-                            activeBundleId = String(components[1])
-                        } else {
-                            activeBundleId = nil
-                        }
-                    } else {
-                        activeBundleId = nil
-                    }
-                } else {
-                    activeBundleId = nil
-                }
-            }
-
-            if let bundleId = activeBundleId {
+            if let bundleId = getActiveBundleId() {
                 if case .success(let storeDir) = bundleStoreDir() {
                     let bundleDir = (storeDir as NSString).appendingPathComponent(bundleId)
                     if fileSystem.fileExists(atPath: bundleDir) {
@@ -1215,6 +1329,14 @@ class BundleFileStorageService: BundleStorageService {
         }
     }
 
+    func getBundleId() -> String? {
+        return getActiveBundleMetadataSnapshot()?.bundleId
+    }
+
+    func getManifest() -> ManifestAssets {
+        return getActiveBundleMetadataSnapshot()?.manifest ?? [:]
+    }
+
     func resetChannel() -> Result<Bool, Error> {
         guard case .success = setBundleURL(localPath: nil) else {
             return .failure(BundleStorageError.unknown(nil))

package/ios/HotUpdater/Internal/CohortService.swift

@@ -0,0 +1,63 @@
+import Foundation
+import UIKit
+
+final class CohortService {
+    private let userDefaults: UserDefaults
+
+    // Keep the legacy key so existing custom cohorts continue to work.
+    private let cohortKey = "HotUpdater_CustomCohort"
+    private let fallbackIdentifierKey = "HotUpdater_FallbackCohortIdentifier"
+
+    init(userDefaults: UserDefaults = .standard) {
+        self.userDefaults = userDefaults
+    }
+
+    private func hashString(_ value: String) -> Int32 {
+        var hash: Int32 = 0
+
+        for scalar in value.unicodeScalars {
+            hash = (hash &* 31) &+ Int32(scalar.value)
+        }
+
+        return hash
+    }
+
+    private func defaultNumericCohort(for identifier: String) -> String {
+        let hash = Int64(hashString(identifier))
+        let normalized = Int((hash % 1000 + 1000) % 1000) + 1
+        return String(normalized)
+    }
+
+    private func fallbackIdentifier() -> String {
+        if let fallbackId = userDefaults.string(forKey: fallbackIdentifierKey), !fallbackId.isEmpty {
+            return fallbackId
+        }
+
+        let fallbackId = UUID().uuidString
+        userDefaults.set(fallbackId, forKey: fallbackIdentifierKey)
+        return fallbackId
+    }
+
+    func setCohort(_ cohort: String) {
+        if cohort.isEmpty {
+            return
+        }
+        userDefaults.set(cohort, forKey: cohortKey)
+    }
+
+    func getCohort() -> String {
+        if let cohort = userDefaults.string(forKey: cohortKey), !cohort.isEmpty {
+            return cohort
+        }
+
+        let initialCohort: String
+        if let idfv = UIDevice.current.identifierForVendor?.uuidString, !idfv.isEmpty {
+            initialCohort = defaultNumericCohort(for: idfv)
+        } else {
+            initialCohort = defaultNumericCohort(for: fallbackIdentifier())
+        }
+
+        userDefaults.set(initialCohort, forKey: cohortKey)
+        return initialCohort
+    }
+}

package/ios/HotUpdater/Internal/DecompressService.swift

@@ -5,16 +5,19 @@ import Foundation
  * Automatically detects format by trying each strategy's validation and delegates to appropriate decompression strategy.
  */
 class DecompressService {
-    /// Array of available strategies in order of detection priority
-    private let strategies: [DecompressionStrategy]
+    /// Strategies with reliable file signatures that can be validated cheaply.
+    private let signatureStrategies: [DecompressionStrategy]
+    /// TAR.BR has no reliable magic bytes, so it is attempted as the final fallback.
+    private let tarBrStrategy: DecompressionStrategy
 
     init() {
-        // Order matters: Try ZIP first (clear magic bytes), then TAR.GZ (GZIP magic bytes), then TAR.BR (fallback)
-        self.strategies = [
+        // Order matters: Try ZIP first (clear magic bytes), then TAR.GZ (GZIP magic bytes).
+        // TAR.BR is attempted only after signature-based formats are ruled out.
+        self.signatureStrategies = [
             ZipDecompressionStrategy(),
-            TarGzDecompressionStrategy(),
-            TarBrDecompressionStrategy()
+            TarGzDecompressionStrategy()
         ]
+        self.tarBrStrategy = TarBrDecompressionStrategy()
     }
 
     /**
@@ -31,8 +34,8 @@ class DecompressService {
         let fileName = fileURL.lastPathComponent
         let fileSize = (try? FileManager.default.attributesOfItem(atPath: file)[.size] as? UInt64) ?? 0
 
-        // Try each strategy's validation
-        for strategy in strategies {
+        // Try each signature-based strategy first.
+        for strategy in signatureStrategies {
             if strategy.isValid(file: file) {
                 NSLog("[DecompressService] Using strategy for \(fileName)")
                 try strategy.decompress(file: file, to: destination, progressHandler: progressHandler)
@@ -40,26 +43,21 @@ class DecompressService {
             }
         }
 
-        // No valid strategy found - provide detailed error message
-        let errorMessage = """
-Failed to decompress file: \(fileName) (\(fileSize) bytes)
-
-Tried strategies: ZIP (magic bytes 0x504B0304), TAR.GZ (magic bytes 0x1F8B), TAR.BR (file extension)
-
-Supported formats:
-- ZIP archives (.zip)
-- GZIP compressed TAR archives (.tar.gz)
-- Brotli compressed TAR archives (.tar.br)
+        NSLog("[DecompressService] No ZIP/TAR.GZ signature matched for \(fileName), trying TAR.BR fallback")
 
-Please verify the file is not corrupted and matches one of the supported formats.
-"""
-
-        NSLog("[DecompressService] \(errorMessage)")
-        throw NSError(
-            domain: "DecompressService",
-            code: 1,
-            userInfo: [NSLocalizedDescriptionKey: errorMessage]
-        )
+        do {
+            try tarBrStrategy.decompress(file: file, to: destination, progressHandler: progressHandler)
+            NSLog("[DecompressService] Using TAR.BR fallback for \(fileName)")
+            return
+        } catch {
+            let invalidArchiveError = createInvalidArchiveError(
+                fileName: fileName,
+                fileSize: fileSize,
+                underlyingError: error
+            )
+            NSLog("[DecompressService] \(invalidArchiveError.localizedDescription)")
+            throw invalidArchiveError
+        }
     }
 
     /**
@@ -73,17 +71,42 @@ Please verify the file is not corrupted and matches one of the supported formats
     }
 
     /**
-     * Validates if a file is a valid compressed archive.
+     * Validates if a file matches one of the signature-based archive formats.
      * @param file Path to the file to validate
      * @return true if the file is valid for any strategy
      */
     func isValid(file: String) -> Bool {
-        for strategy in strategies {
+        for strategy in signatureStrategies {
             if strategy.isValid(file: file) {
                 return true
             }
         }
-        NSLog("[DecompressService] No valid strategy found for file: \(file)")
+        NSLog("[DecompressService] No ZIP/TAR.GZ signature matched for file: \(file). TAR.BR is handled during extraction fallback.")
         return false
     }
+
+    private func createInvalidArchiveError(fileName: String, fileSize: UInt64, underlyingError: Error? = nil) -> NSError {
+        let errorMessage = """
+The downloaded bundle file is not a valid compressed archive: \(fileName) (\(fileSize) bytes)
+
+Supported formats:
+- ZIP archives (.zip)
+- GZIP compressed TAR archives (.tar.gz)
+- Brotli compressed TAR archives (.tar.br)
+"""
+
+        var userInfo: [String: Any] = [
+            NSLocalizedDescriptionKey: errorMessage
+        ]
+
+        if let underlyingError {
+            userInfo[NSUnderlyingErrorKey] = underlyingError
+        }
+
+        return NSError(
+            domain: "DecompressService",
+            code: 1,
+            userInfo: userInfo
+        )
+    }
 }

package/ios/HotUpdater/Internal/HotUpdater.mm

@@ -17,6 +17,7 @@
 
 @interface HotUpdater (InternalSharedImpl)
 + (HotUpdaterImpl *)sharedImpl;
++ (NSString *)generateUUIDv7FromTimestamp:(uint64_t)timestampMs;
 @end
 
 namespace {
@@ -171,6 +172,68 @@ extern "C" BOOL HotUpdaterPerformRecoveryReload(void)
   return didTriggerReload;
 }
 
+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";
+#else
+    // Step 1: Try to read HOT_UPDATER_BUILD_TIMESTAMP from Info.plist
+    NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
+    NSString *customValue = infoDictionary[@"HOT_UPDATER_BUILD_TIMESTAMP"];
+
+    // Step 2: If custom value exists and is not empty
+    if (customValue && customValue.length > 0 && ![customValue isEqualToString:@"$(HOT_UPDATER_BUILD_TIMESTAMP)"]) {
+      // Check if it's a timestamp (pure digits) or UUID
+      NSCharacterSet *nonDigits = [[NSCharacterSet decimalDigitCharacterSet] invertedSet];
+      BOOL isTimestamp = ([customValue rangeOfCharacterFromSet:nonDigits].location == NSNotFound);
+
+      if (isTimestamp) {
+        // Convert timestamp (milliseconds) to UUID v7
+        uint64_t timestampMs = [customValue longLongValue];
+        uuid = [HotUpdater generateUUIDv7FromTimestamp:timestampMs];
+        RCTLogInfo(@"[HotUpdater.mm] Using timestamp %@ as MIN_BUNDLE_ID: %@", customValue, uuid);
+      } else {
+        // Use as UUID directly
+        uuid = customValue;
+        RCTLogInfo(@"[HotUpdater.mm] Using custom MIN_BUNDLE_ID from Info.plist: %@", uuid);
+      }
+      return;
+    }
+
+    // Step 3: Fallback to default logic (26-hour subtraction)
+    RCTLogInfo(@"[HotUpdater.mm] No custom MIN_BUNDLE_ID found, using default calculation");
+
+    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];
+#endif
+  });
+  return uuid;
+}
+
 
 // Define Notification names used for observing Swift Core
 NSNotificationName const HotUpdaterDownloadProgressUpdateNotification = @"HotUpdaterDownloadProgressUpdate";
@@ -326,68 +389,11 @@ RCT_EXPORT_MODULE();
 
 // Returns the minimum bundle ID string, either from Info.plist or generated from build timestamp
 - (NSString *)getMinBundleId {
-     static NSString *uuid = nil;
-     static dispatch_once_t onceToken;
-     dispatch_once(&onceToken, ^{
-     #if DEBUG
-         uuid = @"00000000-0000-0000-0000-000000000000";
-     #else
-         // Step 1: Try to read HOT_UPDATER_BUILD_TIMESTAMP from Info.plist
-         NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
-         NSString *customValue = infoDictionary[@"HOT_UPDATER_BUILD_TIMESTAMP"];
-
-         // Step 2: If custom value exists and is not empty
-         if (customValue && customValue.length > 0 && ![customValue isEqualToString:@"$(HOT_UPDATER_BUILD_TIMESTAMP)"]) {
-             // Check if it's a timestamp (pure digits) or UUID
-             NSCharacterSet *nonDigits = [[NSCharacterSet decimalDigitCharacterSet] invertedSet];
-             BOOL isTimestamp = ([customValue rangeOfCharacterFromSet:nonDigits].location == NSNotFound);
-
-             if (isTimestamp) {
-                 // Convert timestamp (milliseconds) to UUID v7
-                 uint64_t timestampMs = [customValue longLongValue];
-                 uuid = [self generateUUIDv7FromTimestamp:timestampMs];
-                 RCTLogInfo(@"[HotUpdater.mm] Using timestamp %@ as MIN_BUNDLE_ID: %@", customValue, uuid);
-             } else {
-                 // Use as UUID directly
-                 uuid = customValue;
-                 RCTLogInfo(@"[HotUpdater.mm] Using custom MIN_BUNDLE_ID from Info.plist: %@", uuid);
-             }
-             return;
-         }
-
-         // Step 3: Fallback to default logic (26-hour subtraction)
-         RCTLogInfo(@"[HotUpdater.mm] No custom MIN_BUNDLE_ID found, using default calculation");
-
-         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"]; // Correct format for __DATE__ __TIME__
-         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 = [self generateUUIDv7FromTimestamp:buildTimestampMs];
-     #endif
-     });
-     return uuid;
+     return HotUpdaterGetMinBundleId();
 }
 
 // Helper method: Generate UUID v7 from timestamp (milliseconds)
-- (NSString *)generateUUIDv7FromTimestamp:(uint64_t)timestampMs {
++ (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)
@@ -582,6 +588,29 @@ RCT_EXPORT_MODULE();
     return baseURL ?: @"";
 }
 
+- (void)setCohort:(NSString *)customId {
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    [impl setCohort:customId];
+}
+
+- (NSString *)getCohort {
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    return [impl getCohort];
+}
+
+- (NSString * _Nullable)getBundleId {
+    NSLog(@"[HotUpdater.mm] getBundleId called");
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    return [impl getBundleId];
+}
+
+- (NSDictionary<NSString *, id> *)getManifest {
+    NSLog(@"[HotUpdater.mm] getManifest called");
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    NSDictionary<NSString *, id> *manifest = [impl getManifest];
+    return manifest ?: @{};
+}
+
 - (void)resetChannel:(RCTPromiseResolveBlock)resolve
               reject:(RCTPromiseRejectBlock)reject {
     HotUpdaterImpl *impl = [HotUpdater sharedImpl];
@@ -673,6 +702,29 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getBaseURL) {
     return baseURL ?: @"";
 }
 
+RCT_EXPORT_METHOD(setCohort:(NSString *)customId) {
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    [impl setCohort:customId];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getCohort) {
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    return [impl getCohort];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getBundleId) {
+    NSLog(@"[HotUpdater.mm] getBundleId called");
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    return [impl getBundleId];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getManifest) {
+    NSLog(@"[HotUpdater.mm] getManifest called");
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    NSDictionary<NSString *, id> *manifest = [impl getManifest];
+    return manifest ?: @{};
+}
+
 RCT_EXPORT_METHOD(resetChannel:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
     HotUpdaterImpl *impl = [HotUpdater sharedImpl];