react-native-stallion 2.4.0-alpha.3 → 2.4.0-alpha.5

package/android/src/main/java/com/stallion/networkmanager/StallionSyncHandler.java

@@ -70,8 +70,8 @@ public class StallionSyncHandler {
       JSONObject data = releaseMeta.optJSONObject("data");
       if (data == null) return;
 
-      handleAppliedReleaseData(data.optJSONObject("appliedBundleData"), appVersion);
-      handleNewReleaseData(data.optJSONObject("newBundleData"));
+     handleAppliedReleaseData(data.optJSONObject("appliedBundleData"), appVersion);
+     handleNewReleaseData(data.optJSONObject("newBundleData"));
     }
   }
 
@@ -91,6 +91,23 @@ public class StallionSyncHandler {
     String newReleaseUrl = newReleaseData.optString("downloadUrl");
     String newReleaseHash = newReleaseData.optString("checksum");
 
+    // Extract diffData if it exists
+    JSONObject diffData = newReleaseData.optJSONObject("bundleDiff");
+    String diffUrl = null;
+    boolean isBundlePatched = false;
+    String bundleDiffId = null;
+    if (diffData != null) {
+      diffUrl = diffData.optString("url");
+      if (diffUrl != null && diffUrl.isEmpty()) {
+        diffUrl = null;
+      }
+      isBundlePatched = diffData.optBoolean("isBundlePatched", false);
+      bundleDiffId = diffData.optString("id");
+      if (bundleDiffId != null && bundleDiffId.isEmpty()) {
+        bundleDiffId = null;
+      }
+    }
+
     StallionStateManager stateManager = StallionStateManager.getInstance();
     String lastRolledBackHash = stateManager.stallionMeta.getLastRolledBackHash();
     String lastUnverifiedHash = stateManager.getStallionConfig().getLastUnverifiedHash();
@@ -102,14 +119,29 @@ public class StallionSyncHandler {
           && !newReleaseHash.equals(lastUnverifiedHash)
     ) {
       if(stateManager.getIsMounted()) {
-        downloadNewRelease(newReleaseHash, newReleaseUrl);
+        downloadNewRelease(newReleaseHash, newReleaseUrl, diffUrl, isBundlePatched, bundleDiffId);
       } else {
-        stateManager.setPendingRelease(newReleaseUrl, newReleaseHash);
+        stateManager.setPendingRelease(newReleaseUrl, newReleaseHash, diffUrl, isBundlePatched, bundleDiffId);
       }
     }
   }
 
+  // Overloaded method for backward compatibility
   public static void downloadNewRelease(String newReleaseHash, String newReleaseUrl) {
+    downloadNewRelease(newReleaseHash, newReleaseUrl, null, false);
+  }
+
+  // Overloaded method for backward compatibility
+  public static void downloadNewRelease(String newReleaseHash, String newReleaseUrl, String diffUrl) {
+    downloadNewRelease(newReleaseHash, newReleaseUrl, diffUrl, false, null);
+  }
+
+  // Overloaded method for backward compatibility
+  public static void downloadNewRelease(String newReleaseHash, String newReleaseUrl, String diffUrl, boolean isBundlePatched) {
+    downloadNewRelease(newReleaseHash, newReleaseUrl, diffUrl, isBundlePatched, null);
+  }
+
+  public static void downloadNewRelease(String newReleaseHash, String newReleaseUrl, String diffUrl, boolean isBundlePatched, String bundleDiffId) {
     // Ensure only one download job runs at a time
     if (!isDownloadInProgress.compareAndSet(false, true)) {
       return; // Exit if another job is already running
@@ -121,12 +153,24 @@ public class StallionSyncHandler {
         + StallionConfigConstants.PROD_DIRECTORY
         + StallionConfigConstants.TEMP_FOLDER_SLOT;
       String projectId = config.getProjectId();
-      String downloadUrl = newReleaseUrl + "?projectId=" + projectId;
+
+      // Use diffUrl if it exists, otherwise use newReleaseUrl
+      String urlToDownload = (diffUrl != null && !diffUrl.isEmpty()) ? diffUrl : newReleaseUrl;
+      String downloadUrl = urlToDownload + "?projectId=" + projectId;
       String publicSigningKey = config.getPublicSigningKey();
 
+      // Track if this is a diff download
+      final boolean isDiffDownload = (diffUrl != null && !diffUrl.isEmpty());
+      // Store original newReleaseUrl for potential retry
+      final String originalNewReleaseUrl = newReleaseUrl;
+      // Store isBundlePatched flag for patch handler
+      final boolean isBundlePatchedFlag = isBundlePatched;
+      // Store bundleDiffId for events
+      final String bundleDiffIdForEvents = bundleDiffId;
+
       long alreadyDownloaded = StallionDownloadCacheManager.getDownloadCache(config, downloadUrl, downloadPath);
 
-      emitDownloadStarted(newReleaseHash, alreadyDownloaded > 0);
+      emitDownloadStarted(newReleaseHash, alreadyDownloaded > 0, bundleDiffIdForEvents);
 
       StallionFileDownloader.downloadBundle(
         downloadUrl,
@@ -144,6 +188,28 @@ public class StallionSyncHandler {
             isDownloadInProgress.set(false);
             StallionDownloadCacheManager.deleteDownloadCache(downloadPath);
 
+            // If this was a diff download, handle patch
+            if (isDiffDownload) {
+              try {
+                // Get base bundle path from current slot
+                String slotPath = stateManager.stallionMeta.getCurrentProdSlotPath();
+                String baseBundlePath = config.getFilesDirectory()
+                  + StallionConfigConstants.PROD_DIRECTORY
+                  + slotPath;
+
+                // Invoke patch handler with isBundlePatched flag
+                StallionPatchHandler.applyPatch(baseBundlePath, downloadPath, isBundlePatchedFlag);
+              } catch (Exception e) {
+                // Patch application failed, retry with full bundle download
+                // Clean up the failed diff download
+                StallionFileManager.deleteFileOrFolderSilently(new File(downloadPath));
+                isDownloadInProgress.set(false);
+                // Retry download with full bundle (no diffUrl)
+                downloadNewRelease(newReleaseHash, originalNewReleaseUrl, null, false, null);
+                return;
+              }
+            }
+
             if(publicSigningKey != null && !publicSigningKey.isEmpty()) {
               if(
                 !StallionSignatureVerification.verifyReleaseSignature(
@@ -158,14 +224,14 @@ public class StallionSyncHandler {
               }
             }
 
-            stateManager.stallionMeta.setCurrentProdSlot(StallionMetaConstants.SlotStates.NEW_SLOT);
-            stateManager.stallionMeta.setProdTempHash(newReleaseHash);
-            String currentProdNewHash = stateManager.stallionMeta.getProdNewHash();
-            if(currentProdNewHash != null && !currentProdNewHash.isEmpty()) {
-              StallionSlotManager.stabilizeProd();
-            }
-            stateManager.syncStallionMeta();
-            emitDownloadSuccess(newReleaseHash);
+          stateManager.stallionMeta.setCurrentProdSlot(StallionMetaConstants.SlotStates.NEW_SLOT);
+          stateManager.stallionMeta.setProdTempHash(newReleaseHash);
+          String currentProdNewHash = stateManager.stallionMeta.getProdNewHash();
+          if(currentProdNewHash != null && !currentProdNewHash.isEmpty()) {
+            StallionSlotManager.stabilizeProd();
+          }
+          stateManager.syncStallionMeta();
+          emitDownloadSuccess(newReleaseHash, bundleDiffIdForEvents);
           }
 
           @Override
@@ -216,10 +282,13 @@ public class StallionSyncHandler {
     );
   }
 
-  private static void emitDownloadSuccess(String releaseHash) {
+  private static void emitDownloadSuccess(String releaseHash, String bundleDiffId) {
     JSONObject successPayload = new JSONObject();
     try {
       successPayload.put("releaseHash", releaseHash);
+      if (bundleDiffId != null && !bundleDiffId.isEmpty()) {
+        successPayload.put("diffId", bundleDiffId);
+      }
     } catch (Exception ignored) { }
     StallionEventManager.getInstance().sendEvent(
       NativeProdEventTypes.DOWNLOAD_COMPLETE_PROD.toString(),
@@ -227,10 +296,13 @@ public class StallionSyncHandler {
     );
   }
 
-  private static void emitDownloadStarted(String releaseHash, Boolean isResume) {
+  private static void emitDownloadStarted(String releaseHash, Boolean isResume, String bundleDiffId) {
     JSONObject successPayload = new JSONObject();
     try {
       successPayload.put("releaseHash", releaseHash);
+      if (bundleDiffId != null && !bundleDiffId.isEmpty()) {
+        successPayload.put("diffId", bundleDiffId);
+      }
     } catch (Exception ignored) { }
     StallionEventManager.getInstance().sendEvent(
       isResume ? NativeProdEventTypes.DOWNLOAD_RESUME_PROD.toString(): NativeProdEventTypes.DOWNLOAD_STARTED_PROD.toString(),

package/android/src/main/java/com/stallion/storage/StallionMeta.java

@@ -1,5 +1,6 @@
 package com.stallion.storage;
 
+import com.stallion.storage.StallionConfigConstants;
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -77,6 +78,17 @@ public class StallionMeta {
     }
   }
 
+  public String getCurrentProdSlotPath() {
+    switch (this.currentProdSlot) {
+      case NEW_SLOT:
+        return StallionConfigConstants.NEW_FOLDER_SLOT;
+      case STABLE_SLOT:
+        return StallionConfigConstants.STABLE_FOLDER_SLOT;
+      default:
+        return StallionConfigConstants.NEW_FOLDER_SLOT;
+    }
+  }
+
   public void setCurrentProdSlot(StallionMetaConstants.SlotStates currentProdSlot) {
     this.currentProdSlot = currentProdSlot;
   }

package/android/src/main/java/com/stallion/storage/StallionStateManager.java

@@ -21,6 +21,9 @@ public class StallionStateManager {
   private boolean isMounted;
   private String pendingReleaseUrl;
   private String pendingReleaseHash;
+  private String pendingReleaseDiffUrl;
+  private boolean pendingReleaseIsBundlePatched;
+  private String pendingReleaseBundleDiffId;
   private boolean isSyncSuccessful;
 
   private StallionStateManager(Context context) {
@@ -30,6 +33,9 @@ public class StallionStateManager {
     this.isMounted = false;
     this.pendingReleaseUrl = "";
     this.pendingReleaseHash = "";
+    this.pendingReleaseDiffUrl = null;
+    this.pendingReleaseIsBundlePatched = false;
+    this.pendingReleaseBundleDiffId = null;
     
     // Reset mount state on initialization (ensures mount marker file is deleted for new session)
     setIsMounted(false);
@@ -116,8 +122,15 @@ public class StallionStateManager {
   }
 
   public void setPendingRelease(String pendingReleaseUrl, String pendingReleaseHash) {
+    setPendingRelease(pendingReleaseUrl, pendingReleaseHash, null, false, null);
+  }
+
+  public void setPendingRelease(String pendingReleaseUrl, String pendingReleaseHash, String diffUrl, boolean isBundlePatched, String bundleDiffId) {
     this.pendingReleaseUrl = pendingReleaseUrl;
     this.pendingReleaseHash = pendingReleaseHash;
+    this.pendingReleaseDiffUrl = diffUrl;
+    this.pendingReleaseIsBundlePatched = isBundlePatched;
+    this.pendingReleaseBundleDiffId = bundleDiffId;
   }
 
   public String getPendingReleaseUrl() {
@@ -128,6 +141,18 @@ public class StallionStateManager {
     return this.pendingReleaseHash;
   }
 
+  public String getPendingReleaseDiffUrl() {
+    return this.pendingReleaseDiffUrl;
+  }
+
+  public boolean getPendingReleaseIsBundlePatched() {
+    return this.pendingReleaseIsBundlePatched;
+  }
+
+  public String getPendingReleaseBundleDiffId() {
+    return this.pendingReleaseBundleDiffId;
+  }
+
   public boolean getIsSyncSuccessful() { return this.isSyncSuccessful; }
 
   public void setIsSyncSuccessful(boolean isSyncSuccessful) { this.isSyncSuccessful = isSyncSuccessful; }

package/android/src/main/java/com/stallion/utils/StallionBSPatch.java

@@ -0,0 +1,30 @@
+package com.stallion.utils;
+
+public class StallionBSPatch {
+  
+  static {
+    System.loadLibrary("stallion-bspatch");
+  }
+  
+  /**
+   * Applies a bsdiff patch file to oldFile, writing the result to newFile.
+   * 
+   * @param oldFile Path to the old/base file
+   * @param newFile Path where the patched file will be written
+   * @param patchFile Path to the patch file
+   * @return true if patch was applied successfully, false otherwise
+   */
+  public static boolean applyPatch(String oldFile, String newFile, String patchFile) {
+    int result = nativeApplyPatch(oldFile, newFile, patchFile);
+    if (result == 0) {
+      return true;
+    } else {
+      android.util.Log.e("StallionBSPatch", "BSPatch failed with code: " + result + 
+          " (old: " + oldFile + ", patch: " + patchFile + ")");
+      return false;
+    }
+  }
+  
+  private static native int nativeApplyPatch(String oldFile, String newFile, String patchFile);
+}
+

package/ios/Stallion.xcodeproj/project.pbxproj

@@ -10,6 +10,7 @@
 		5E555C0D2413F4C50049A1A2 /* Stallion.m in Sources */ = {isa = PBXBuildFile; fileRef = B3E7B5891CC2AC0600A0062D /* Stallion.m */; };
 		F4FF95D7245B92E800C19C63 /*  Stallion.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4FF95D6245B92E800C19C63 /*  Stallion.swift */; };
 		F4FF95DA245B92EB00C19C63 /* StallionDeviceInfo.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4FF95D9245B92EB00C19C63 /* StallionDeviceInfo.swift */; };
+		F4FF95E1245B92F000C19C68 /* bspatch.c in Sources */ = {isa = PBXBuildFile; fileRef = F4FF95DF245B92EE00C19C66 /* bspatch.c */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -31,6 +32,8 @@
 		F4FF95D6245B92E800C19C63 /* Stallion.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Stallion.swift; sourceTree = "<group>"; };
 		F4FF95D7245B92E900C19C63 /* StallionVersion.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "StallionVersion.h"; sourceTree = "<group>"; };
 		F4FF95D9245B92EB00C19C63 /* StallionDeviceInfo.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "StallionDeviceInfo.swift"; sourceTree = "<group>"; };
+		F4FF95DF245B92EE00C19C66 /* bspatch.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = bspatch.c; sourceTree = "<group>"; };
+		F4FF95E0245B92EF00C19C67 /* bspatch_bridge.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = bspatch_bridge.h; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -57,6 +60,8 @@
 			children = (
 				F4FF95D6245B92E800C19C63 /* Stallion.swift */,
 				F4FF95D9245B92EB00C19C63 /* StallionDeviceInfo.swift */,
+				F4FF95DF245B92EE00C19C66 /* bspatch.c */,
+				F4FF95E0245B92EF00C19C67 /* bspatch_bridge.h */,
 				B3E7B5891CC2AC0600A0062D /* Stallion.m */,
 				F4FF95D5245B92E700C19C63 /* Stallion-Bridging-Header.h */,
 				F4FF95D7245B92E900C19C63 /* StallionVersion.h */,
@@ -123,6 +128,7 @@
 			files = (
 				F4FF95D7245B92E800C19C63 /* Stallion.swift in Sources */,
 				F4FF95DA245B92EB00C19C63 /* StallionDeviceInfo.swift in Sources */,
+				F4FF95E1245B92F000C19C68 /* bspatch.c in Sources */,
 				B3E7B58A1CC2AC0600A0062D /* Stallion.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;

package/ios/main/Stallion-Bridging-Header.h

@@ -8,3 +8,4 @@
 #import <StallionMetaConstants.h>
 #import <StallionSlotManager.h>
 #import <StallionExceptionHandler.h>
+#import "bspatch_bridge.h"

package/ios/main/Stallion.m

@@ -1,5 +1,7 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
+#import "StallionStateManager.h"
+#import "StallionMeta.h"
 
 @interface RCT_EXTERN_MODULE(Stallion, NSObject)
 
@@ -40,3 +42,23 @@ RCT_EXTERN_METHOD(restart)
 }
 
 @end
+
+// Forward declare the class (implemented in Swift)
+@class Stallion;
+
+@interface Stallion (Sync)
+@end
+
+@implementation Stallion (Sync)
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getActiveReleaseHash)
+{
+  StallionStateManager *stateManager = [StallionStateManager sharedInstance];
+  if (stateManager && stateManager.stallionMeta) {
+    NSString *hash = [stateManager.stallionMeta getActiveReleaseHash];
+    return hash ? hash : @"";
+  }
+  return @"";
+}
+
+@end

package/ios/main/Stallion.swift

@@ -46,9 +46,16 @@ class Stallion: RCTEventEmitter {
               !pendingReleaseUrl.isEmpty,
               !pendingReleaseHash.isEmpty else { return }
 
-        StallionSyncHandler.downloadNewRelease(newReleaseHash: pendingReleaseHash, newReleaseUrl: pendingReleaseUrl)
+        let pendingReleaseDiffUrl = stallionStateManager.pendingReleaseDiffUrl
+        let pendingReleaseIsBundlePatched = stallionStateManager.pendingReleaseIsBundlePatched
+        let pendingReleaseBundleDiffId = stallionStateManager.pendingReleaseBundleDiffId
+        
+        StallionSyncHandler.downloadNewRelease(newReleaseHash: pendingReleaseHash, newReleaseUrl: pendingReleaseUrl, diffUrl: pendingReleaseDiffUrl, isBundlePatched: pendingReleaseIsBundlePatched, bundleDiffId: pendingReleaseBundleDiffId)
         stallionStateManager.pendingReleaseUrl = ""
         stallionStateManager.pendingReleaseHash = ""
+        stallionStateManager.pendingReleaseDiffUrl = nil
+        stallionStateManager.pendingReleaseIsBundlePatched = false
+        stallionStateManager.pendingReleaseBundleDiffId = nil
     }
 
   @objc func getStallionConfig(_ promise: RCTPromiseResolveBlock, rejecter: RCTPromiseRejectBlock) {

package/ios/main/StallionBSPatch.swift

@@ -0,0 +1,35 @@
+//
+//  StallionBSPatch.swift
+//  react-native-stallion
+//
+//  Created by Thor963 on 04/11/25.
+//
+
+import Foundation
+
+class StallionBSPatch {
+    
+    static func applyPatch(oldFile: String, newFile: String, patchFile: String) -> Bool {
+        #if os(iOS)
+        // Use embedded C implementation on iOS
+        // Swift automatically bridges String to const char * for C functions
+        let result = oldFile.withCString { oldPath in
+            newFile.withCString { newPath in
+                patchFile.withCString { patchPath in
+                    bspatch_apply(oldPath, newPath, patchPath)
+                }
+            }
+        }
+        
+        if result == 0 {
+            return true
+        } else {
+            NSLog("BSPatch failed with code: %d (old: %@, patch: %@)", result, oldFile, patchFile)
+            return false
+        }
+        #else
+        NSLog("BSPatch not supported on this platform.")
+        return false
+        #endif
+    }
+}

package/ios/main/StallionMeta.h

@@ -35,6 +35,7 @@
 - (void)setLastRolledBackHashWithTimestamp:(NSString *)lastRolledBackHash;
 - (void)markSuccessfulLaunch:(NSString *)releaseHash;
 - (NSInteger)getSuccessfulLaunchCount:(NSString *)releaseHash;
+- (NSString *)getCurrentProdSlotPath;
 + (instancetype)fromDictionary:(NSDictionary *)dict;
 
 @end

package/ios/main/StallionMeta.m

@@ -6,6 +6,7 @@
 //
 
 #import "StallionMeta.h"
+#import "StallionObjConstants.h"
 
 @implementation StallionMeta
 
@@ -170,4 +171,15 @@
      }
  }
 
+- (NSString *)getCurrentProdSlotPath {
+    switch (self.currentProdSlot) {
+        case SlotStateNewSlot:
+            return StallionObjConstants.new_folder_slot;
+        case SlotStateStableSlot:
+            return StallionObjConstants.stable_folder_slot;
+        default:
+            return nil;
+    }
+}
+
 @end

package/ios/main/StallionModule.m

@@ -75,9 +75,9 @@
 
     switch (stallionMeta.currentStageSlot) {
         case SlotStateNewSlot:
-            return [self resolveBundlePath:[NSString stringWithFormat:@"%@/%@/%@", baseFolderPath, [StallionObjConstants stage_directory], [StallionObjConstants new_folder_slot]]
-                          defaultBundlePath:defaultBundlePath
-                               releaseHash:stallionMeta.stageNewHash isProd:false];
+           return [self resolveBundlePath:[NSString stringWithFormat:@"%@/%@/%@", baseFolderPath, [StallionObjConstants stage_directory], [StallionObjConstants new_folder_slot]]
+                         defaultBundlePath:defaultBundlePath
+                              releaseHash:stallionMeta.stageNewHash isProd:false];
         default:
             return [self getDefaultBundle:defaultBundlePath];
     }

package/ios/main/StallionPatchHandler.swift

@@ -0,0 +1,206 @@
+//
+//  StallionPatchHandler.swift
+//  react-native-stallion
+//
+//  Created by Thor963 on 29/11/25.
+//
+
+import Foundation
+
+class StallionPatchHandler {
+    
+    /**
+     * Applies a patch to the base bundle using the diff file.
+     *
+     * @param baseBundlePath The path to the base bundle folder
+     * @param diffPath The path to the downloaded diff folder
+     * @param isBundlePatched Whether the bundle file uses bspatch (true) or file-based patching (false)
+     * @throws Error if patch application fails at any point
+     */
+    static func applyPatch(baseBundlePath: String, diffPath: String, isBundlePatched: Bool) throws {
+        let baseBundleDir = URL(fileURLWithPath: baseBundlePath)
+        let diffDir = URL(fileURLWithPath: diffPath)
+        
+        // Validate inputs
+        var isDirectory: ObjCBool = false
+        guard FileManager.default.fileExists(atPath: baseBundlePath, isDirectory: &isDirectory),
+              isDirectory.boolValue else {
+            throw NSError(domain: "StallionPatchHandler", code: -1,
+                         userInfo: [NSLocalizedDescriptionKey: "Base bundle path does not exist or is not a directory: \(baseBundlePath)"])
+        }
+        
+        guard FileManager.default.fileExists(atPath: diffPath, isDirectory: &isDirectory),
+              isDirectory.boolValue else {
+            throw NSError(domain: "StallionPatchHandler", code: -2,
+                         userInfo: [NSLocalizedDescriptionKey: "Diff path does not exist or is not a directory: \(diffPath)"])
+        }
+        
+        // Path to manifest.json (in diffDir, not in unzip folder based on user's changes)
+        let manifestFile = diffDir.appendingPathComponent("manifest.json")
+        guard FileManager.default.fileExists(atPath: manifestFile.path) else {
+            throw NSError(domain: "StallionPatchHandler", code: -3,
+                         userInfo: [NSLocalizedDescriptionKey: "Manifest file does not exist: \(manifestFile.path)"])
+        }
+        
+        // Create a temporary directory for the patched bundle
+        let tempPatchedDir = diffDir.deletingLastPathComponent()
+            .appendingPathComponent(diffDir.lastPathComponent + "_patched_temp")
+        
+        // Use defer to ensure cleanup
+        defer {
+            // Clean up temporary directory
+            if FileManager.default.fileExists(atPath: tempPatchedDir.path) {
+                try? FileManager.default.removeItem(at: tempPatchedDir)
+            }
+        }
+        
+        // Copy base bundle to temporary location
+        StallionFileManager.copyFileOrDirectory(from: baseBundlePath, to: tempPatchedDir.path)
+        
+        // Verify copy succeeded
+        guard FileManager.default.fileExists(atPath: tempPatchedDir.path) else {
+            throw NSError(domain: "StallionPatchHandler", code: -8,
+                         userInfo: [NSLocalizedDescriptionKey: "Failed to copy base bundle to temporary directory"])
+        }
+        
+        // Read and parse manifest.json
+        let manifest = try readManifest(manifestFile: manifestFile)
+        
+        // Apply manifest changes (diffDir contains the files, not diffUnzipDir)
+        try applyManifestChanges(manifest: manifest, diffDir: diffDir, patchedDir: tempPatchedDir, isBundlePatched: isBundlePatched)
+        
+        // Replace diffPath contents with patched result
+        // First, clear the diffPath
+        let diffDirContents = try FileManager.default.contentsOfDirectory(at: diffDir, includingPropertiesForKeys: nil)
+        for file in diffDirContents {
+            try? FileManager.default.removeItem(at: file)
+        }
+        
+        // Copy patched result to diffPath
+        let tempPatchedContents = try FileManager.default.contentsOfDirectory(at: tempPatchedDir, includingPropertiesForKeys: nil)
+        for file in tempPatchedContents {
+            let destFile = diffDir.appendingPathComponent(file.lastPathComponent)
+            StallionFileManager.copyFileOrDirectory(from: file.path, to: destFile.path)
+        }
+    }
+    
+    /**
+     * Reads and parses the manifest.json file.
+     */
+    private static func readManifest(manifestFile: URL) throws -> [String: Any] {
+        let data = try Data(contentsOf: manifestFile)
+        guard let manifest = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] else {
+            throw NSError(domain: "StallionPatchHandler", code: -4,
+                         userInfo: [NSLocalizedDescriptionKey: "Failed to parse manifest JSON"])
+        }
+        return manifest
+    }
+    
+    /**
+     * Applies the changes specified in the manifest to the patched directory.
+     */
+    private static func applyManifestChanges(manifest: [String: Any], diffDir: URL, patchedDir: URL, isBundlePatched: Bool) throws {
+        // Apply deletions first
+        if let deleted = manifest["deleted"] as? [String] {
+            for filePath in deleted {
+                let fileToDelete = patchedDir.appendingPathComponent(filePath)
+                if FileManager.default.fileExists(atPath: fileToDelete.path) {
+                    try? FileManager.default.removeItem(at: fileToDelete)
+                }
+            }
+        }
+        
+        // Apply modifications (files that already exist)
+        if let modified = manifest["modified"] as? [String] {
+            for filePath in modified {
+                try applyFileFromDiff(diffDir: diffDir, patchedDir: patchedDir, relativeFilePath: filePath, isBundlePatched: isBundlePatched)
+            }
+        }
+        
+        // Apply additions (new files)
+        if let added = manifest["added"] as? [String] {
+            for filePath in added {
+                try applyFileFromDiff(diffDir: diffDir, patchedDir: patchedDir, relativeFilePath: filePath, isBundlePatched: isBundlePatched)
+            }
+        }
+    }
+    
+    /**
+     * Copies a file from the diff directory to the patched directory.
+     * If the file is main.jsbundle and isBundlePatched is true, applies bspatch instead of copying.
+     */
+    private static func applyFileFromDiff(diffDir: URL, patchedDir: URL, relativeFilePath: String, isBundlePatched: Bool) throws {
+        let sourceFile = diffDir.appendingPathComponent(relativeFilePath)
+        let destFile = patchedDir.appendingPathComponent(relativeFilePath)
+        
+        guard FileManager.default.fileExists(atPath: sourceFile.path) else {
+            throw NSError(domain: "StallionPatchHandler", code: -5,
+                         userInfo: [NSLocalizedDescriptionKey: "Source file does not exist in diff: \(sourceFile.path)"])
+        }
+        
+        // Ensure parent directory exists
+        let parentDir = destFile.deletingLastPathComponent()
+        try? FileManager.default.createDirectory(at: parentDir, withIntermediateDirectories: true, attributes: nil)
+        
+        // Check if this is the main.jsbundle file
+        let bundleFileName = StallionObjConstants.bundle_file_name
+        let normalizedPath = relativeFilePath.replacingOccurrences(of: "\\", with: "/")
+        let isBundleFile = normalizedPath.hasSuffix("/" + (bundleFileName ?? "")) || normalizedPath == bundleFileName
+        
+        if isBundleFile && isBundlePatched {
+            // This is the bundle file and it's a binary patch - use bspatch
+            // The base bundle file should already exist in the patched directory (from the initial copy)
+            let baseBundleFile = destFile
+            
+            guard FileManager.default.fileExists(atPath: baseBundleFile.path) else {
+                throw NSError(domain: "StallionPatchHandler", code: -6,
+                             userInfo: [NSLocalizedDescriptionKey: "Base bundle file does not exist for patching: \(baseBundleFile.path)"])
+            }
+            
+            // Create a temporary file for the patched output
+            let tempPatchedFile = destFile.deletingLastPathComponent()
+                .appendingPathComponent(destFile.lastPathComponent + ".tmp")
+            
+            do {
+                // Apply bspatch: patch the base bundle using the diff file
+                let success = StallionBSPatch.applyPatch(
+                    oldFile: baseBundleFile.path,
+                    newFile: tempPatchedFile.path,
+                    patchFile: sourceFile.path
+                )
+                
+                guard success else {
+                    throw NSError(domain: "StallionPatchHandler", code: -7,
+                                 userInfo: [NSLocalizedDescriptionKey: "Failed to apply bspatch to \(relativeFilePath)"])
+                }
+                
+                // Replace the original file with the patched one
+                if FileManager.default.fileExists(atPath: destFile.path) {
+                    try? FileManager.default.removeItem(at: destFile)
+                }
+                StallionFileManager.moveFile(from: tempPatchedFile.path, to: destFile.path)
+                
+                // Verify move succeeded
+                guard FileManager.default.fileExists(atPath: destFile.path) else {
+                    throw NSError(domain: "StallionPatchHandler", code: -8,
+                                 userInfo: [NSLocalizedDescriptionKey: "Failed to move patched bundle file"])
+                }
+            } catch {
+                // Clean up temp file on error
+                if FileManager.default.fileExists(atPath: tempPatchedFile.path) {
+                    try? FileManager.default.removeItem(at: tempPatchedFile)
+                }
+                throw error
+            }
+        } else {
+            // Regular file - copy normally
+            StallionFileManager.moveFile(from: sourceFile.path, to: destFile.path)
+            
+            // Verify copy succeeded
+            guard FileManager.default.fileExists(atPath: destFile.path) else {
+                throw NSError(domain: "StallionPatchHandler", code: -9,
+                             userInfo: [NSLocalizedDescriptionKey: "Failed to copy file: \(relativeFilePath)"])
+            }
+        }
+    }
+}