react-native-instantpay-code-push 1.1.8 → 1.2.0

package/ios/InstantpayCodePush.mm

@@ -1,12 +1,340 @@
 #import "InstantpayCodePush.h"
+#import <React/RCTReloadCommand.h>
+#import <React/RCTLog.h>
 
-@implementation InstantpayCodePush
-- (NSNumber *)multiply:(double)a b:(double)b {
-    NSNumber *result = @(a * b);
+#if __has_include("InstantpayCodePush/InstantpayCodePush-Swift.h")
+#import "InstantpayCodePush/InstantpayCodePush-Swift.h"
+#else
+#import "InstantpayCodePush-Swift.h"
+#endif
 
-    return result;
+// Define Notification names used for observing Swift Core
+NSNotificationName const IpayCodePushDownloadProgressUpdateNotification = @"IpayCodePushDownloadProgressUpdate";
+NSNotificationName const IpayCodePushDownloadDidFinishNotification = @"IpayCodePushDownloadDidFinish";
+
+@implementation InstantpayCodePush {
+    bool hasListeners;
+    // Keep track of tasks ONLY for removing observers when this ObjC instance is invalidated
+    NSMutableSet<NSURLSessionTask *> *observedTasks; // Changed to NSURLSessionTask for broader compatibility if needed
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        observedTasks = [NSMutableSet set];
+        
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(handleDownloadProgress:)
+                                                     name:IpayCodePushDownloadProgressUpdateNotification
+                                                   object:nil];
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(handleDownloadCompletion:)
+                                                     name:IpayCodePushDownloadDidFinishNotification
+                                                   object:nil];
+        
+        _lastUpdateTime = 0;
+    }
+    return self;
 }
 
+// Clean up observers when module is invalidated or deallocated
+- (void)invalidate {
+    RCTLogInfo(@"[InstantpayCodePush.mm] invalidate called, removing observers.");
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    // Swift side should handle KVO observer removal for its tasks
+    [super invalidate];
+}
+
+- (void)dealloc {
+    RCTLogInfo(@"[InstantpayCodePush.mm] dealloc called, removing observers.");
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+//RCT_EXPORT_MODULE();
+
+#pragma mark - Singleton Instance
+
+// Static singleton IpayCodePushImpl getter
++ (IpayCodePushImpl *)sharedImpl {
+    static IpayCodePushImpl *_sharedImpl = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        _sharedImpl = [[IpayCodePushImpl alloc] init];
+    });
+    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
+
+- (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 IPAY_CODE_PUSH_BUILD_TIMESTAMP from Info.plist
+            NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
+            NSString *customValue = infoDictionary[@"IPAY_CODE_PUSH_BUILD_TIMESTAMP"];
+            
+            // Step 2: If custom value exists and is not empty
+            if (customValue && customValue.length > 0 && ![customValue isEqualToString:@"$(IPAY_CODE_PUSH_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(@"[InstantpayCodePush.mm] Using timestamp %@ as MIN_BUNDLE_ID: %@", customValue, uuid);
+                 } else {
+                     // Use as UUID directly
+                     uuid = customValue;
+                     RCTLogInfo(@"[InstantpayCodePush.mm] Using custom MIN_BUNDLE_ID from Info.plist: %@", uuid);
+                 }
+                 return;
+             }
+        
+            // Step 3: Fallback to default logic (26-hour subtraction)
+            RCTLogInfo(@"[InstantpayCodePush.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(@"[InstantpayCodePush.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;
+}
+
+// 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": [IpayCodePushImpl appVersion] ?: [NSNull null],
+        @"CHANNEL": [[InstantpayCodePush sharedImpl] getChannel] ?: [NSNull null],
+        @"FINGERPRINT_HASH": [[InstantpayCodePush sharedImpl] getFingerprintHash] ?: [NSNull null]
+    };
+}
+
+// Get bundleURL with default bundle using singleton
++ (NSURL *)bundleURL {
+    return [[InstantpayCodePush sharedImpl] bundleURLWithBundle:[NSBundle mainBundle]];
+}
+
+// Get bundleURL with specific bundle using singleton
++ (NSURL *)bundleURLWithBundle:(NSBundle *)bundle {
+    return [[InstantpayCodePush sharedImpl] bundleURLWithBundle:bundle];
+}
+
+// Get bundleURL with default bundle using instance impl
+- (NSURL *)bundleURL {
+    return [[InstantpayCodePush sharedImpl] bundleURLWithBundle:[NSBundle mainBundle]];
+}
+
+// Get bundleURL with specific bundle using instance impl
+- (NSURL *)bundleURLWithBundle:(NSBundle *)bundle {
+    return [[InstantpayCodePush sharedImpl] bundleURLWithBundle:bundle];
+}
+
+#pragma mark - Progress Updates & Event Emitting (Keep in ObjC Wrapper)
+
+- (void)handleDownloadProgress:(NSNotification *)notification {
+     if (!hasListeners) return;
+
+     NSDictionary *userInfo = notification.userInfo;
+     NSNumber *progressNum = userInfo[@"progress"];
+
+     if (progressNum) {
+         double progress = [progressNum doubleValue];
+         NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970] * 1000;
+         if ((currentTime - self.lastUpdateTime) >= 100 || progress >= 1.0) {
+             self.lastUpdateTime = currentTime;
+             [self sendEvent:@"onProgress" body:@{@"progress": @(progress)}];
+         }
+     }
+ }
+
+- (void)handleDownloadCompletion:(NSNotification *)notification {
+      NSURLSessionTask *task = notification.object; // Task that finished
+      RCTLogInfo(@"[InstantpayCodePush.mm] Received download completion notification for task: %@", task.originalRequest.URL);
+      // Swift side handles KVO observer removal internally now when task finishes.
+      // No specific cleanup needed here based on this notification anymore.
+}
+
+#pragma mark - React Native Events (Keep as is)
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[@"onProgress"];
+}
+
+- (void)startObserving {
+    hasListeners = YES;
+}
+
+- (void)stopObserving {
+    hasListeners = NO;
+}
+
+- (void)sendEvent:(NSString *)name body:(id)body {
+    if (hasListeners) {
+        [self sendEventWithName:name body:body];
+    }
+}
+
+#pragma mark - React Native Exports
+
+- (void)reload:(RCTPromiseResolveBlock)resolve
+        reject:(RCTPromiseRejectBlock)reject {
+    RCTLogInfo(@"[InstantpayCodePush.mm] IpayCodePush requested a reload");
+    dispatch_async(dispatch_get_main_queue(), ^{
+        @try {
+            IpayCodePushImpl *impl = [InstantpayCodePush sharedImpl];
+            NSURL *bundleURL = [impl bundleURLWithBundle:[NSBundle mainBundle]];
+            RCTLogInfo(@"[InstantpayCodePush.mm] Reloading with bundle URL: %@", bundleURL);
+            if (bundleURL && super.bridge) {
+                [super.bridge setValue:bundleURL forKey:@"bundleURL"];
+            } else if (!super.bridge) {
+                RCTLogWarn(@"[InstantpayCodePush.mm] Bridge is nil, cannot set bundleURL for reload.");
+            }
+            RCTTriggerReloadCommandListeners(@"IpayCodePush requested a reload");
+            resolve(nil);
+        } @catch (NSError *error) {
+            RCTLogError(@"[InstantpayCodePush.mm] Failed to reload: %@", error);
+            reject(@"RELOAD_ERROR", error.description, error);
+        }
+    });
+}
+
+- (void)updateBundle:(JS::NativeInstantpayCodePush::UpdateBundleParams &)params
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject {
+    NSLog(@"[InstantpayCodePush.mm] updateBundle called.");
+    NSMutableDictionary *paramDict = [NSMutableDictionary dictionary];
+    if (params.bundleId()) {
+        paramDict[@"bundleId"] = params.bundleId();
+    }
+    if (params.fileUrl()) {
+        paramDict[@"fileUrl"] = params.fileUrl();
+    }
+    if (params.fileHash()) {
+        paramDict[@"fileHash"] = params.fileHash();
+    }
+
+    IpayCodePushImpl *impl = [InstantpayCodePush sharedImpl];
+    [impl updateBundle:paramDict resolver:resolve rejecter:reject];
+}
+
+- (NSDictionary *)notifyAppReady:(JS::NativeInstantpayCodePush::SpecNotifyAppReadyParams &)params {
+    NSString *bundleId = nil;
+    if (params.bundleId()) {
+        bundleId = params.bundleId();
+    }
+    NSLog(@"[InstantpayCodePush.mm] notifyAppReady called with bundleId: %@", bundleId);
+    IpayCodePushImpl *impl = [InstantpayCodePush sharedImpl];
+    return [impl notifyAppReadyWithBundleId:bundleId];
+}
+
+- (NSArray<NSString *> *)getCrashHistory {
+    NSLog(@"[InstantpayCodePush.mm] getCrashHistory called");
+    IpayCodePushImpl *impl = [InstantpayCodePush sharedImpl];
+    NSArray<NSString *> *crashHistory = [impl getCrashHistory];
+    return crashHistory ?: @[];
+}
+
+- (NSNumber *)clearCrashHistory {
+    NSLog(@"[InstantpayCodePush.mm] clearCrashHistory called");
+    IpayCodePushImpl *impl = [InstantpayCodePush sharedImpl];
+    BOOL result = [impl clearCrashHistory];
+    return @(result);
+}
+
+- (NSString *)getBaseURL {
+    NSLog(@"[InstantpayCodePush.mm] getBaseURL called");
+    IpayCodePushImpl *impl = [InstantpayCodePush sharedImpl];
+    NSString *baseURL = [impl getBaseURL];
+    return baseURL ?: @"";
+}
+
+- (facebook::react::ModuleConstants<JS::NativeInstantpayCodePush::Constants::Builder>)constantsToExport {
+    return [self getConstants];
+}
+
+- (facebook::react::ModuleConstants<JS::NativeInstantpayCodePush::Constants::Builder>)getConstants {
+    IpayCodePushImpl *impl = [InstantpayCodePush sharedImpl];
+    return facebook::react::typedConstants<JS::NativeInstantpayCodePush::Constants::Builder>({
+        .MIN_BUNDLE_ID = [self getMinBundleId],
+        .APP_VERSION = [IpayCodePushImpl appVersion],
+        .CHANNEL = [impl getChannel],
+        .FINGERPRINT_HASH = [impl getFingerprintHash],
+        .KEYSTORE_PUBLIC_KEY = nil
+    });
+}
+
+#pragma mark - Turbo Module Support (Keep as is)
+
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
 {

package/ios/IpayCodePushHelper.swift

@@ -0,0 +1,57 @@
+//
+//  IpayCodePushHelper.swift
+//  InstantpayCodePush
+//
+//  Created by Dhananjay kumar on 06/02/26.
+//
+import os
+
+@objcMembers public class IpayCodePushHelper {
+    
+    private init() {}
+    
+    static let MAIN_LOG_TAG: String = "*IpayCodePush -> ";
+    
+    let WARNING_LOG = "WARNING_LOG"
+
+    let ERROR_LOG = "ERROR_LOG"
+    
+    static func logPrint(classTag: String, log: String?) -> Void {
+        if(log == nil){
+            return
+        }
+        
+        let fullTagName = "\(MAIN_LOG_TAG) \(classTag)"
+        
+        if let isEnableLog: Bool = Bundle.main.object(forInfoDictionaryKey: "IpayCodePush_Log") as! Bool? {
+            if(isEnableLog){
+                let logger = Logger(subsystem: "com.instantpay.ipayCodePush", category: "IpayCodePushHelper")
+                logger.info("\(fullTagName)")
+            }
+        }
+    }
+    
+    static func logPrint(logType: String, classTag: String, log: String?){
+        if(log == nil){
+            return
+        }
+        
+        let fullTagName = "\(MAIN_LOG_TAG) \(classTag)"
+        
+        if let isEnableLog: Bool = Bundle.main.object(forInfoDictionaryKey: "IpayCodePush_Log") as! Bool? {
+            if(isEnableLog){
+                let logger = Logger(subsystem: "com.instantpay.ipayCodePush", category: "IpayCodePushHelper")
+                if(logType == "WARNING_LOG"){
+                    logger.warning("\(fullTagName)")
+                }
+                else if(logType == "ERROR_LOG"){
+                    logger.error("\(fullTagName)")
+                }
+                else{
+                    logger.info("\(fullTagName)")
+                }
+            }
+        }
+    }
+    
+}

package/ios/IpayCodePushImpl.swift

@@ -0,0 +1,297 @@
+//
+//  IpayCodePushImpl.swift
+//  InstantpayCodePush
+//
+//  Created by Dhananjay kumar on 06/02/26.
+//
+
+import Foundation
+import React
+
+@objcMembers public class IpayCodePushImpl: NSObject {
+    
+    private let bundleStorage: BundleStorageService
+    private let preferences: PreferencesService
+    
+    let CLASS_TAG = "*IpayCodePushImpl"
+    
+    private static let DEFAULT_CHANNEL = "production"
+    
+    // MARK: - Initialization
+    
+    /**
+     * Convenience initializer that creates and configures all dependencies.
+     */
+    public convenience override init() {
+        let fileSystem = FileManagerService()
+        let isolationKey = IpayCodePushImpl.getIsolationKey()
+        let preferences = VersionedPreferencesService()
+        let downloadService = URLSessionDownloadService()
+        let decompressService = DecompressService()
+
+        let bundleStorage = BundleFileStorageService(
+            fileSystem: fileSystem,
+            downloadService: downloadService,
+            decompressService: decompressService,
+            preferences: preferences,
+            isolationKey: isolationKey
+        )
+
+        self.init(bundleStorage: bundleStorage, preferences: preferences)
+    }
+    
+    /**
+     * Primary initializer with dependency injection.
+     * @param bundleStorage Service for bundle storage operations
+     * @param preferences Service for preference storage
+     */
+    internal init(bundleStorage: BundleStorageService, preferences: PreferencesService) {
+        self.bundleStorage = bundleStorage
+        self.preferences = preferences
+        super.init()
+
+        // Configure preferences with isolation key
+        let isolationKey = IpayCodePushImpl.getIsolationKey()
+        (preferences as? VersionedPreferencesService)?.configure(isolationKey: isolationKey)
+    }
+    
+    // MARK: - Static Properties
+    
+    /**
+     * Returns the app version from main bundle info.
+     */
+    public static var appVersion: String? {
+        return Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+    }
+    
+    /**
+     * Returns the app version from main bundle info.
+     */
+    public static var appChannel: String {
+        return Bundle.main.object(forInfoDictionaryKey: "IPAY_CODE_PUSH_CHANNEL") as? String ?? Self.DEFAULT_CHANNEL
+    }
+    
+    /**
+     * Gets the complete isolation key for preferences storage.
+     * @return The isolation key in format: ipaycodepush_{fingerprintOrVersion}_{channel}_
+     */
+    public static func getIsolationKey() -> String {
+        // Get fingerprint hash from Info.plist
+        let fingerprintHash = Bundle.main.object(forInfoDictionaryKey: "IPAY_CODE_PUSH_FINGERPRINT_HASH") as? String
+
+        // Get app version and channel
+        let appVersion = self.appVersion ?? "unknown"
+        let appChannel = self.appChannel
+
+        // Include both fingerprint hash and app version for complete isolation
+        let baseKey: String
+        if let hash = fingerprintHash, !hash.isEmpty {
+            baseKey = "\(hash)_\(appVersion)"
+        } else {
+            baseKey = appVersion
+        }
+
+        return "ipaycodepush_\(baseKey)_\(appChannel)_"
+    }
+    
+    // MARK: - Channel Management
+    
+    /**
+     * Gets the current update channel.
+     * @return The channel name or nil if not set
+     */
+    public func getChannel() -> String {
+        return Bundle.main.object(forInfoDictionaryKey: "IPAY_CODE_PUSH_CHANNEL") as? String ?? Self.DEFAULT_CHANNEL
+    }
+    
+    /**
+     * Gets the current fingerprint hash.
+     * @return The fingerprint hash or nil if not set
+     */
+    public func getFingerprintHash() -> String? {
+        return Bundle.main.object(forInfoDictionaryKey: "IPAY_CODE_PUSH_FINGERPRINT_HASH") as? String
+    }
+    
+    // MARK: - Bundle URL Management
+    
+    /**
+     * Gets the URL to the bundle file.
+     * @param bundle instance to lookup the JavaScript bundle resource. Defaults to Bundle.main.
+     * @return URL to the bundle or nil
+     */
+    public func bundleURL(bundle: Bundle = Bundle.main) -> URL? {
+        return bundleStorage.getBundleURL(bundle: bundle)
+    }
+    
+    // MARK: - Bundle Update
+    
+    /**
+     * Updates the bundle from JavaScript bridge.
+     * This method acts as the primary error boundary for all bundle operations.
+     * @param params Dictionary with bundleId and fileUrl parameters
+     * @param resolve Promise resolve callback
+     * @param reject Promise reject callback
+     */
+    public func updateBundle(
+        _ params: NSDictionary?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        
+        do {
+            // Validate parameters (this runs on calling thread - typically JS thread)
+            guard let data = params else {
+                let error = NSError(domain: "IpayCodePush", code: 0,
+                                   userInfo: [NSLocalizedDescriptionKey: "Missing or invalid parameters for updateBundle"])
+                reject("UNKNOWN_ERROR", error.localizedDescription, error)
+                return
+            }
+
+            guard let bundleId = data["bundleId"] as? String, !bundleId.isEmpty else {
+                let error = NSError(domain: "IpayCodePush", code: 0,
+                                   userInfo: [NSLocalizedDescriptionKey: "Missing or empty 'bundleId'"])
+                reject("MISSING_BUNDLE_ID", error.localizedDescription, error)
+                return
+            }
+
+            let fileUrlString = data["fileUrl"] as? String ?? ""
+
+            var fileUrl: URL? = nil
+            if !fileUrlString.isEmpty {
+                guard let url = URL(string: fileUrlString) else {
+                    let error = NSError(domain: "IpayCodePush", code: 0,
+                                       userInfo: [NSLocalizedDescriptionKey: "Invalid 'fileUrl' provided: \(fileUrlString)"])
+                    reject("INVALID_FILE_URL", error.localizedDescription, error)
+                    return
+                }
+                fileUrl = url
+            }
+
+            // Extract fileHash if provided
+            let fileHash = data["fileHash"] as? String
+
+            // Extract progress callback if provided
+            let progressCallback = data["progressCallback"] as? RCTResponseSenderBlock
+            
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "updateBundle called with bundleId: \(bundleId), fileUrl: \(fileUrl?.absoluteString ?? "nil"), fileHash: \(fileHash ?? "nil")")
+
+            // Heavy work is delegated to bundle storage service with safe error handling
+            bundleStorage.updateBundle(bundleId: bundleId, fileUrl: fileUrl, fileHash: fileHash, progressHandler: { progress in
+                // Call JS progress callback if provided
+                if let callback = progressCallback {
+                    DispatchQueue.main.async {
+                        callback([progress])
+                    }
+                }
+            }) { [weak self] result in
+                guard self != nil else {
+                    let error = NSError(domain: "IpayCodePush", code: 0,
+                                       userInfo: [NSLocalizedDescriptionKey: "Internal error: self deallocated during update"])
+                    DispatchQueue.main.async {
+                        reject("SELF_DEALLOCATED", error.localizedDescription, error)
+                    }
+                    return
+                }
+                // Return results on main thread for React Native bridge
+                DispatchQueue.main.async {
+                    switch result {
+                    case .success:
+                        IpayCodePushHelper.logPrint(classTag: self!.CLASS_TAG, log: "Update successful for \(bundleId). Resolving promise.")
+                        resolve(true)
+                    case .failure(let error):
+                        IpayCodePushHelper.logPrint(classTag: self!.CLASS_TAG, log: "Update failed for \(bundleId) - Error: \(error)")
+
+                        let normalizedCode = IpayCodePushImpl.normalizeErrorCode(from: error)
+                        let nsError = error as NSError
+                        reject(normalizedCode, nsError.localizedDescription, nsError)
+                    }
+                }
+            }
+        } catch let error {
+            // Main error boundary - catch and convert all errors to JS rejection
+            let nsError = error as NSError
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Error in updateBundleFromJS - Domain: \(nsError.domain), Code: \(nsError.code), Description: \(nsError.localizedDescription)")
+
+            reject("UNKNOWN_ERROR", nsError.localizedDescription, nsError)
+        }
+    }
+    
+    /**
+     * Normalizes native errors to a small, predictable set of JS-facing error codes.
+     * Rare or platform-specific codes are collapsed to UNKNOWN_ERROR to reduce surface area.
+     */
+    private static func normalizeErrorCode(from error: Error) -> String {
+        let baseCode: String
+
+        if let storageError = error as? BundleStorageError {
+            // Collapse signature sub-errors into a single public code
+            if case .signatureVerificationFailed = storageError {
+                baseCode = "SIGNATURE_VERIFICATION_FAILED"
+            } else {
+                baseCode = storageError.errorCodeString
+            }
+        } else if error is SignatureVerificationError {
+            baseCode = "SIGNATURE_VERIFICATION_FAILED"
+        } else {
+            baseCode = "UNKNOWN_ERROR"
+        }
+
+        return userFacingErrorCodes.contains(baseCode) ? baseCode : "UNKNOWN_ERROR"
+    }
+    
+    // Error codes we intentionally expose to JS callers.
+    private static let userFacingErrorCodes: Set<String> = [
+        "MISSING_BUNDLE_ID",
+        "INVALID_FILE_URL",
+        "DIRECTORY_CREATION_FAILED",
+        "DOWNLOAD_FAILED",
+        "INCOMPLETE_DOWNLOAD",
+        "EXTRACTION_FORMAT_ERROR",
+        "INVALID_BUNDLE",
+        "INSUFFICIENT_DISK_SPACE",
+        "SIGNATURE_VERIFICATION_FAILED",
+        "MOVE_OPERATION_FAILED",
+        "BUNDLE_IN_CRASHED_HISTORY",
+        "SELF_DEALLOCATED",
+        "UNKNOWN_ERROR",
+    ]
+    
+    // MARK: - Rollback Support
+    
+    /**
+     * Notifies the system that the app has successfully started with the given bundle.
+     * If the bundle matches the staging bundle, it promotes to stable.
+     * @param bundleId The ID of the currently running bundle
+     * @return true if promotion was successful or no action was needed
+     */
+    public func notifyAppReady(bundleId: String) -> [String: Any] {
+        return bundleStorage.notifyAppReady(bundleId: bundleId)
+    }
+    
+    /**
+     * Gets the crashed bundle history.
+     * @return Array of crashed bundle IDs
+     */
+    public func getCrashHistory() -> [String] {
+        return bundleStorage.getCrashHistory().bundles.map { $0.bundleId }
+    }
+    
+    /**
+     * Clears the crashed bundle history.
+     * @return true if clearing was successful
+     */
+    public func clearCrashHistory() -> Bool {
+        return bundleStorage.clearCrashHistory()
+    }
+
+    /**
+     * Gets the base URL for the current active bundle directory.
+     * Returns the file:// URL to the bundle directory with trailing slash.
+     * This is used for Expo DOM components to construct full asset paths.
+     * @return Base URL string (e.g., "file:///var/.../bundle-store/abc123/") or empty string
+     */
+    public func getBaseURL() -> String {
+        return bundleStorage.getBaseURL()
+    }
+    
+}