react-native-stallion 2.3.0-alpha.5 → 2.3.0-alpha.7

package/android/build.gradle

@@ -103,11 +103,3 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 }
-
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "Stallion"
-    codegenJavaPackageName = "com.stallion"
-  }
-}

package/android/src/main/cpp/CMakeLists.txt

@@ -17,3 +17,9 @@ target_link_libraries(
   stallion-crash
   ${log-lib}
 )
+
+# Fix for 16KB page size compatibility (required for Android 15+)
+# This ensures LOAD segments are aligned at 16KB boundaries
+set_target_properties(stallion-crash PROPERTIES
+  LINK_FLAGS "-Wl,-z,max-page-size=16384"
+)

package/android/src/main/cpp/stallion_signal_handler.cpp

@@ -7,6 +7,7 @@
 
 static char g_marker_path[512];
 static char g_mount_marker_path[512];
+static struct sigaction g_previous_handlers[32]; // Store previous handlers for chaining
 
 // Async-signal-safe function to check if mount marker exists
 static int is_mounted() {
@@ -36,11 +37,28 @@ static void write_crash_marker_json(int signal, int mounted) {
   }
 }
 
-static void stallion_signal_handler(int sig) {
+static void stallion_signal_handler(int sig, siginfo_t *info, void *context) {
   // Read mount state at crash time (async-signal-safe)
   int mounted = is_mounted();
   // Write JSON marker with crash info and autoRollback flag
   write_crash_marker_json(sig, mounted);
+  
+  // Chain to previous handler if it exists and is valid (bubble up)
+  if (sig >= 0 && sig < 32) {
+    struct sigaction *prev = &g_previous_handlers[sig];
+    if (prev->sa_handler != SIG_DFL && prev->sa_handler != SIG_IGN && prev->sa_handler != NULL) {
+      // Prevent infinite loop - don't call ourselves
+      if (prev->sa_sigaction != stallion_signal_handler) {
+        if (prev->sa_flags & SA_SIGINFO) {
+          prev->sa_sigaction(sig, info, context);
+        } else if (prev->sa_handler != SIG_DFL && prev->sa_handler != SIG_IGN) {
+          prev->sa_handler(sig);
+        }
+      }
+    }
+  }
+  
+  // Restore default and raise to proceed with crash
   signal(sig, SIG_DFL);
   raise(sig);
 }
@@ -54,9 +72,20 @@ Java_com_stallion_utils_StallionExceptionHandler_initNativeSignalHandler(
   snprintf(g_mount_marker_path, sizeof(g_mount_marker_path), "%s/%s", path, "stallion_mount.marker");
   env->ReleaseStringUTFChars(filesDir, path);
 
-  signal(SIGABRT, stallion_signal_handler);
-  signal(SIGSEGV, stallion_signal_handler);
-  signal(SIGILL,  stallion_signal_handler);
-  signal(SIGBUS,  stallion_signal_handler);
-  signal(SIGFPE,  stallion_signal_handler);
+  // Use sigaction instead of signal for better handler chaining
+  struct sigaction action;
+  sigemptyset(&action.sa_mask);
+  action.sa_flags = SA_SIGINFO;
+  action.sa_sigaction = stallion_signal_handler;
+  
+  int signals[] = {SIGABRT, SIGSEGV, SIGILL, SIGBUS, SIGFPE};
+  int signalCount = sizeof(signals) / sizeof(signals[0]);
+  
+  for (int i = 0; i < signalCount; i++) {
+    int sig = signals[i];
+    // Store previous handler before installing ours (for chaining)
+    sigaction(sig, NULL, &g_previous_handlers[sig]);
+    // Now install our handler
+    sigaction(sig, &action, NULL);
+  }
 }

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

@@ -9,51 +9,61 @@ import com.stallion.storage.StallionStateManager;
 
 import org.json.JSONObject;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 public class StallionExceptionHandler {
 
   private static Thread.UncaughtExceptionHandler _androidUncaughtExceptionHandler;
   private static Thread _exceptionThread;
   private static Throwable _exceptionThrowable;
-  private static boolean isErrorBoundaryInitialized = false;
-  private static boolean isNativeSignalsInitialized = false;
-  private static boolean hasProcessedNativeCrashMarker = false;
+  private static final AtomicBoolean isErrorBoundaryInitialized = new AtomicBoolean(false);
+  private static final AtomicBoolean isNativeSignalsInitialized = new AtomicBoolean(false);
+  private static final AtomicBoolean hasProcessedNativeCrashMarker = new AtomicBoolean(false);
+  private static final AtomicBoolean isRollbackPerformed = new AtomicBoolean(false);
 
   public static void initErrorBoundary() {
-    if (isErrorBoundaryInitialized) {
+    // Use compareAndSet to atomically check and set initialization flag
+    if (!isErrorBoundaryInitialized.compareAndSet(false, true)) {
       return; // Prevent multiple initializations
     }
-    isErrorBoundaryInitialized = true;
+
+    // Reset rollback flag when initializing exception handler
+    isRollbackPerformed.set(false);
 
     _androidUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
     Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
       _exceptionThread = thread;
       _exceptionThrowable = throwable;
 
-      // Safely trim the stack trace string
-      String stackTraceString = Log.getStackTraceString(throwable);
-      stackTraceString = stackTraceString.length() > 900
-        ? stackTraceString.substring(0, 900) + "..."
-        : stackTraceString;
+      try {
+        // Safely trim the stack trace string
+        String stackTraceString = Log.getStackTraceString(throwable);
+        stackTraceString = stackTraceString.length() > 900
+          ? stackTraceString.substring(0, 900) + "..."
+          : stackTraceString;
 
-      StallionStateManager stateManager = StallionStateManager.getInstance();
-      StallionMetaConstants.SwitchState switchState = stateManager.stallionMeta.getSwitchState();
+        StallionStateManager stateManager = StallionStateManager.getInstance();
+        StallionMetaConstants.SwitchState switchState = stateManager.stallionMeta.getSwitchState();
 
-      if (switchState == StallionMetaConstants.SwitchState.PROD) {
-        handleProdState(stackTraceString, stateManager);
-      } else if (switchState == StallionMetaConstants.SwitchState.STAGE) {
-        handleStageState(stackTraceString, stateManager);
-      } else {
+        if (switchState == StallionMetaConstants.SwitchState.PROD) {
+          handleProdState(stackTraceString, stateManager);
+        } else if (switchState == StallionMetaConstants.SwitchState.STAGE) {
+          handleStageState(stackTraceString, stateManager);
+        } else {
+          continueExceptionFlow();
+        }
+      } catch (Exception e) {
+        // If anything goes wrong in our handler, ensure we still chain to previous handler
         continueExceptionFlow();
       }
     });
 
     // Initialize native signal handler once and process any prior crash marker
     try {
-      if (!isNativeSignalsInitialized) {
+      if (isNativeSignalsInitialized.compareAndSet(false, true)) {
         System.loadLibrary("stallion-crash");
         String filesDir = StallionStateManager.getInstance().getStallionConfig().getFilesDirectory();
         initNativeSignalHandler(filesDir);
-        isNativeSignalsInitialized = true;
       }
       processNativeCrashMarkerIfPresent();
     } catch (Throwable ignored) {}
@@ -78,14 +88,30 @@ public class StallionExceptionHandler {
     boolean isAutoRollback = !stateManager.getIsMounted();
     String currentHash = stateManager.stallionMeta.getHashAtCurrentProdSlot();
 
-    // Emit exception event
-    emitException(stackTraceString, currentHash, isAutoRollback, true);
+    // Only prevent multiple executions for auto rollback cases
+    // Launch crashes (when mounted) can continue to be registered
+    if (isAutoRollback) {
+      // Use compareAndSet to atomically check and set the flag
+      if (!isRollbackPerformed.compareAndSet(false, true)) {
+        // Flag was already true, skip duplicate rollback
+        continueExceptionFlow();
+        return;
+      }
+    }
+
+    // Emit exception event (wrap in try-catch to ensure chaining happens)
+    try {
+      emitException(stackTraceString, currentHash, isAutoRollback, true);
+    } catch (Exception ignored) { }
 
     // Perform rollback if auto-rollback is enabled
     if (isAutoRollback) {
-      StallionSlotManager.rollbackProd(true, stackTraceString);
+      try {
+        StallionSlotManager.rollbackProd(true, stackTraceString);
+      } catch (Exception ignored) { }
     }
 
+    // Always chain to previous handler, even if rollback or emit failed
     continueExceptionFlow();
   }
 
@@ -93,13 +119,29 @@ public class StallionExceptionHandler {
     boolean isAutoRollback = !stateManager.getIsMounted();
     String currentStageHash = stateManager.stallionMeta.getStageNewHash();
 
-    // Emit exception event
-    emitException(stackTraceString, currentStageHash, isAutoRollback, false);
+    // Only prevent multiple executions for auto rollback cases
+    // Launch crashes (when mounted) can continue to be registered
+    if (isAutoRollback) {
+      // Use compareAndSet to atomically check and set the flag
+      if (!isRollbackPerformed.compareAndSet(false, true)) {
+        // Flag was already true, skip duplicate rollback
+        continueExceptionFlow();
+        return;
+      }
+    }
+
+    // Emit exception event (wrap in try-catch to ensure chaining happens)
+    try {
+      emitException(stackTraceString, currentStageHash, isAutoRollback, false);
+    } catch (Exception ignored) { }
 
     if(isAutoRollback) {
-      StallionSlotManager.rollbackStage();
+      try {
+        StallionSlotManager.rollbackStage();
+      } catch (Exception ignored) { }
     }
 
+    // Always chain to previous handler, even if rollback or emit failed
     continueExceptionFlow();
   }
 
@@ -111,7 +153,7 @@ public class StallionExceptionHandler {
 
   private static void processNativeCrashMarkerIfPresent() {
     try {
-      if (hasProcessedNativeCrashMarker) { return; }
+      if (hasProcessedNativeCrashMarker.get()) { return; }
       String filesDir = StallionStateManager.getInstance().getStallionConfig().getFilesDirectory();
       java.io.File marker = new java.io.File(filesDir + "/stallion_crash.marker");
       if (marker.exists()) {
@@ -149,22 +191,36 @@ public class StallionExceptionHandler {
         if (switchState == StallionMetaConstants.SwitchState.PROD) {
           String currentHash = stateManager.stallionMeta.getHashAtCurrentProdSlot();
           // Use isAutoRollback from previous crash, not current session state
-          emitException(stackTraceString, currentHash, isAutoRollback, true);
+          try {
+            emitException(stackTraceString, currentHash, isAutoRollback, true);
+          } catch (Exception ignored) { }
           if (isAutoRollback) {
-            StallionSlotManager.rollbackProd(true, stackTraceString);
+            // Only prevent multiple executions for auto rollback cases
+            if (isRollbackPerformed.compareAndSet(false, true)) {
+              try {
+                StallionSlotManager.rollbackProd(true, stackTraceString);
+              } catch (Exception ignored) { }
+            }
           }
         } else if (switchState == StallionMetaConstants.SwitchState.STAGE) {
           String currentStageHash = stateManager.stallionMeta.getStageNewHash();
           // Use isAutoRollback from previous crash, not current session state
-          emitException(stackTraceString, currentStageHash, isAutoRollback, false);
+          try {
+            emitException(stackTraceString, currentStageHash, isAutoRollback, false);
+          } catch (Exception ignored) { }
           if (isAutoRollback) {
-            StallionSlotManager.rollbackStage();
+            // Only prevent multiple executions for auto rollback cases
+            if (isRollbackPerformed.compareAndSet(false, true)) {
+              try {
+                StallionSlotManager.rollbackStage();
+              } catch (Exception ignored) { }
+            }
           }
         }
 
         // delete marker
         StallionFileManager.deleteFileOrFolderSilently(marker);
-        hasProcessedNativeCrashMarker = true;
+        hasProcessedNativeCrashMarker.set(true);
       }
     } catch (Exception ignored) {}
   }

package/ios/main/StallionExceptionHandler.mm

@@ -12,57 +12,55 @@
 #import "StallionMeta.h"
 #import "StallionMetaConstants.h"
 #import "StallionObjConstants.h"
+#import "StallionFileManager.h"
 #import <signal.h>
-#import <execinfo.h>
+#import <unistd.h>
+#import <fcntl.h>
 #import <React/RCTLog.h>
 #import <React/RCTUtils.h>
-#include <exception>
-#include <cxxabi.h>
-#include <string>
+#include <atomic>
 
 // Forward declarations
 void handleException(NSException *exception);
 void handleSignal(int signal, siginfo_t *info, void *context);
 static void performStallionRollback(NSString *errorString);
 static void setupSignalHandlers(void);
-void handleCppTerminate(void);
+static void processNativeCrashMarkerIfPresent(void);
+
+// Async-signal-safe crash marker storage
+static char g_marker_path[512];
+static char g_mount_marker_path[512];
 
 @implementation StallionExceptionHandler
 
 NSUncaughtExceptionHandler *_defaultExceptionHandler;
-std::terminate_handler _defaultTerminateHandler;
-BOOL exceptionAlertDismissed = FALSE;
-static BOOL rollbackPerformed = FALSE;
-static BOOL isInitialized = FALSE;
+static std::atomic<bool> exceptionAlertDismissed(false);
+static std::atomic<bool> exceptionAlertShowing(false);
+static std::atomic<bool> rollbackPerformed(false);
+static std::atomic<bool> hasProcessedNativeCrashMarker(false);
 static struct sigaction _previousHandlers[32]; // Store previous handlers for chaining
 
 + (void)initExceptionHandler {
-    // Prevent multiple initializations
-    if (isInitialized) {
-        return;
-    }
-    isInitialized = TRUE;
-    
-    // Reset rollback flag when initializing exception handler
-    [self resetRollbackFlag];
-    
-    // Store and set Objective-C exception handler
-    if (!_defaultExceptionHandler) {
-        _defaultExceptionHandler = NSGetUncaughtExceptionHandler();
-    }
-    NSSetUncaughtExceptionHandler(&handleException);
-
-    // Store and set C++ terminate handler
-    if (!_defaultTerminateHandler) {
-        _defaultTerminateHandler = std::get_terminate();
-    }
-    std::set_terminate(handleCppTerminate);
-    
-    // Setup signal handlers using sigaction with chaining
-    setupSignalHandlers();
-    
-    // Initialize JavaScript exception handler
-    [self initJavaScriptExceptionHandler];
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        // Reset rollback flag when initializing exception handler
+        [self resetRollbackFlag];
+        
+        // Store and set Objective-C exception handler
+        if (!_defaultExceptionHandler) {
+            _defaultExceptionHandler = NSGetUncaughtExceptionHandler();
+        }
+        NSSetUncaughtExceptionHandler(&handleException);
+        
+        // Setup signal handlers using sigaction with chaining
+        setupSignalHandlers();
+        
+        // Initialize JavaScript exception handler
+        [self initJavaScriptExceptionHandler];
+        
+        // Process any crash marker from previous session
+        processNativeCrashMarkerIfPresent();
+    });
 }
 
 + (void)initJavaScriptExceptionHandler {
@@ -77,7 +75,7 @@ static struct sigaction _previousHandlers[32]; // Store previous handlers for ch
 }
 
 + (void)resetRollbackFlag {
-    rollbackPerformed = FALSE;
+    rollbackPerformed.store(false);
 }
 
 @end
@@ -93,14 +91,13 @@ static void performStallionRollback(NSString *errorString) {
   
   // Only prevent multiple executions for auto rollback cases
   // Launch crashes (when mounted) can continue to be registered
-  if (rollbackPerformed && isAutoRollback) {
-      NSLog(@"Auto rollback already performed, skipping duplicate rollback attempt");
-      return;
-  }
-  
-  // Set rollback flag only for auto rollback cases
   if (isAutoRollback) {
-    rollbackPerformed = TRUE;
+    // Use compare-and-swap to atomically check and set the flag
+    bool expected = false;
+    if (!rollbackPerformed.compare_exchange_strong(expected, true)) {
+      // Flag was already true, skip duplicate rollback
+      return;
+    }
   }
   
   if (errorString.length > 900) {
@@ -121,19 +118,24 @@ static void performStallionRollback(NSString *errorString) {
         }
 
   } else if (meta.switchState == SwitchStateStage) {
+    NSString *currentStageHash = meta.stageNewHash ?: @"";
     
-    if(isAutoRollback) {
-      [StallionSlotManager rollbackStage];
-    }
-    
+    // Emit exception event before rollback (consistent with PROD and Android)
     [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_stage_event
           eventPayload:@{
               @"meta": errorString,
-              StallionObjConstants.release_hash_key: meta.stageNewHash,
+              StallionObjConstants.release_hash_key: currentStageHash,
               StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
           }];
+    
+    if(isAutoRollback) {
+      [StallionSlotManager rollbackStage];
+    }
 
-      if(!exceptionAlertDismissed) {
+      // Check if alert is already showing (atomic check to prevent duplicates)
+      bool expectedShowing = false;
+      if (exceptionAlertShowing.compare_exchange_strong(expectedShowing, true)) {
+        // We successfully claimed the right to show the alert
         UIAlertController *alert = [UIAlertController alertControllerWithTitle:@"Stallion Exception Handler"
            message:[NSString stringWithFormat:@"%@\n%@",
                     @"A crash occurred in the app. Build was rolled back. Check crash report below. Continue crash to invoke other exception handlers. \n \n",
@@ -143,7 +145,8 @@ static void performStallionRollback(NSString *errorString) {
         [alert addAction:[UIAlertAction actionWithTitle:@"Continue Crash"
                                                   style:UIAlertActionStyleDefault
                                                 handler:^(UIAlertAction *action) {
-                                                    exceptionAlertDismissed = TRUE;
+                                                    // Set flag to true only when button is pressed
+                                                    exceptionAlertDismissed.store(true);
                                                 }]];
 
         UIApplication *app = [UIApplication sharedApplication];
@@ -153,7 +156,8 @@ static void performStallionRollback(NSString *errorString) {
             [rootViewController presentViewController:alert animated:YES completion:nil];
         });
 
-        while (exceptionAlertDismissed == FALSE) {
+        // Wait for user to press the button (exceptionAlertDismissed becomes true)
+        while (!exceptionAlertDismissed.load()) {
             [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
         }
       }
@@ -162,10 +166,47 @@ static void performStallionRollback(NSString *errorString) {
 
 #pragma mark - Signal Handler Setup
 
+// Async-signal-safe function to check if mount marker exists
+static int is_mounted_safe(void) {
+    int fd = open(g_mount_marker_path, O_RDONLY);
+    if (fd >= 0) {
+        close(fd);
+        return 1; // Mounted
+    }
+    return 0; // Not mounted
+}
+
+// Async-signal-safe JSON writing (minimal JSON for crash marker)
+static void write_crash_marker_json_safe(int signal, int mounted) {
+    int fd = open(g_marker_path, O_CREAT | O_WRONLY | O_TRUNC, 0600);
+    if (fd >= 0) {
+        // Write JSON: {"signal":X,"isAutoRollback":true/false,"crashLog":"signal=X\n"}
+        // isAutoRollback = !mounted (auto rollback if not mounted)
+        int autoRollback = !mounted;
+        char json[512];
+        int len = snprintf(json, sizeof(json),
+            "{\"signal\":%d,\"isAutoRollback\":%s,\"crashLog\":\"signal=%d\\n\"}",
+            signal, autoRollback ? "true" : "false", signal);
+        if (len > 0 && len < (int)sizeof(json)) {
+            (void)write(fd, json, len);
+        }
+        close(fd);
+    }
+}
+
 static void setupSignalHandlers(void) {
+    // Initialize marker paths from StallionStateManager
+    StallionStateManager *stateManager = [StallionStateManager sharedInstance];
+    NSString *filesDir = stateManager.stallionConfig.filesDirectory;
+    if (filesDir) {
+        const char *path = [filesDir UTF8String];
+        snprintf(g_marker_path, sizeof(g_marker_path), "%s/%s", path, "stallion_crash.marker");
+        snprintf(g_mount_marker_path, sizeof(g_mount_marker_path), "%s/%s", path, "stallion_mount.marker");
+    }
+    
     struct sigaction action;
     sigemptyset(&action.sa_mask);
-    action.sa_flags = SA_SIGINFO | SA_ONSTACK;
+    action.sa_flags = SA_SIGINFO;
     action.sa_sigaction = handleSignal;
     
     // List of signals to catch - comprehensive coverage
@@ -206,28 +247,15 @@ void handleException(NSException *exception) {
 }
 
 void handleSignal(int signalVal, siginfo_t *info, void *context) {
-    void *callstack[128];
-    int frames = backtrace(callstack, 128);
-    char **symbols = backtrace_symbols(callstack, frames);
 
-    NSMutableString *stackTrace = [NSMutableString stringWithFormat:@"Signal %d was raised.\n", signalVal];
-    
-    // Add signal info if available
-    if (info) {
-        [stackTrace appendFormat:@"Signal Code: %d\n", info->si_code];
-        if (info->si_addr) {
-            [stackTrace appendFormat:@"Fault Address: %p\n", info->si_addr];
-        }
+    if (!rollbackPerformed.load()) {
+        // Async-signal-safe operations only
+        // Read mount state at crash time (async-signal-safe)
+        int mounted = is_mounted_safe();
+        // Write JSON marker with crash info and autoRollback flag
+        write_crash_marker_json_safe(signalVal, mounted);
     }
     
-    [stackTrace appendString:@"Stack trace:\n"];
-    for (int i = 0; i < frames; ++i) {
-        [stackTrace appendFormat:@"%s\n", symbols[i]];
-    }
-    free(symbols);
-
-    performStallionRollback(stackTrace);
-
     // Chain to previous handler if it exists and is valid (bubble up)
     if (signalVal >= 0 && signalVal < 32) {
         struct sigaction *prev = &_previousHandlers[signalVal];
@@ -248,46 +276,104 @@ void handleSignal(int signalVal, siginfo_t *info, void *context) {
     raise(signalVal);
 }
 
-void handleCppTerminate(void) {
-    std::exception_ptr ex = std::current_exception();
-    NSString *errorString = @"C++ terminate() called";
-    
-    if (ex) {
-        try {
-            std::rethrow_exception(ex);
-        } catch (const std::exception &e) {
-            const char *name = abi::__cxa_demangle(typeid(e).name(), 0, 0, 0);
-            errorString = [NSString stringWithFormat:@"C++ Exception: %s - %s", 
-                          name ? name : typeid(e).name(), e.what()];
-            if (name) free((void*)name);
-        } catch (const std::string &s) {
-            errorString = [NSString stringWithFormat:@"C++ Exception (string): %s", s.c_str()];
-        } catch (const char *s) {
-            errorString = [NSString stringWithFormat:@"C++ Exception (char*): %s", s];
-        } catch (...) {
-            errorString = @"C++ Exception: Unknown type";
+#pragma mark - Crash Marker Processing
+
+static void processNativeCrashMarkerIfPresent(void) {
+    @try {
+        if (hasProcessedNativeCrashMarker.load()) {
+            return;
         }
-    }
-    
-    // Get stack trace
-    void *callstack[128];
-    int frames = backtrace(callstack, 128);
-    char **symbols = backtrace_symbols(callstack, frames);
-    
-    NSMutableString *fullError = [NSMutableString stringWithString:errorString];
-    [fullError appendString:@"\nStack trace:\n"];
-    for (int i = 0; i < frames; ++i) {
-        [fullError appendFormat:@"%s\n", symbols[i]];
-    }
-    free(symbols);
-    
-    performStallionRollback(fullError);
-    
-    // Chain to default terminate handler
-    if (_defaultTerminateHandler) {
-        _defaultTerminateHandler();
-    } else {
-        abort();
-    }
+        
+        StallionStateManager *stateManager = [StallionStateManager sharedInstance];
+        NSString *filesDir = stateManager.stallionConfig.filesDirectory;
+        NSString *markerPath = [NSString stringWithFormat:@"%@/stallion_crash.marker", filesDir];
+        
+        NSFileManager *fileManager = [NSFileManager defaultManager];
+        if ([fileManager fileExistsAtPath:markerPath]) {
+            NSError *error = nil;
+            NSString *jsonContent = [NSString stringWithContentsOfFile:markerPath
+                                                              encoding:NSUTF8StringEncoding
+                                                                 error:&error];
+            
+            if (jsonContent && !error) {
+                NSString *stackTraceString = @"";
+                BOOL isAutoRollback = NO;
+                
+                @try {
+                    // Parse JSON from previous crash
+                    NSData *jsonData = [jsonContent dataUsingEncoding:NSUTF8StringEncoding];
+                    NSDictionary *crashMarker = [NSJSONSerialization JSONObjectWithData:jsonData
+                                                                                options:0
+                                                                                  error:&error];
+                    if (crashMarker && !error) {
+                        // Extract crash log and autoRollback flag from marker
+                        stackTraceString = crashMarker[@"crashLog"] ?: @"";
+                        // Use the autoRollback flag that was determined at crash time (previous session)
+                        isAutoRollback = [crashMarker[@"isAutoRollback"] boolValue];
+                    }
+                } @catch (NSException *e) {
+                    // Fallback for old format (non-JSON)
+                    stackTraceString = jsonContent;
+                    // Default to true for old format (conservative approach)
+                    isAutoRollback = YES;
+                }
+                
+                if (stackTraceString.length > 900) {
+                    stackTraceString = [stackTraceString substringToIndex:900];
+                }
+                
+                StallionMeta *meta = stateManager.stallionMeta;
+                SwitchState switchState = meta.switchState;
+                
+                if (switchState == SwitchStateProd) {
+                    NSString *currentHash = [meta getActiveReleaseHash] ?: @"";
+                    // Use isAutoRollback from previous crash, not current session state
+                    @try {
+                        [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_prod_event
+                                                              eventPayload:@{
+                                                                  @"meta": stackTraceString,
+                                                                  StallionObjConstants.release_hash_key: currentHash,
+                                                                  StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
+                                                              }];
+                    } @catch (NSException *e) { }
+                    
+                    if (isAutoRollback) {
+                        // Only prevent multiple executions for auto rollback cases
+                        bool expected = false;
+                        if (rollbackPerformed.compare_exchange_strong(expected, true)) {
+                            @try {
+                                [StallionSlotManager rollbackProdWithAutoRollback:YES errorString:stackTraceString];
+                            } @catch (NSException *e) { }
+                        }
+                    }
+                } else if (switchState == SwitchStateStage) {
+                    NSString *currentStageHash = meta.stageNewHash ?: @"";
+                    // Use isAutoRollback from previous crash, not current session state
+                    @try {
+                        [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_stage_event
+                                                              eventPayload:@{
+                                                                  @"meta": stackTraceString,
+                                                                  StallionObjConstants.release_hash_key: currentStageHash,
+                                                                  StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
+                                                              }];
+                    } @catch (NSException *e) { }
+                    
+                    if (isAutoRollback) {
+                        // Only prevent multiple executions for auto rollback cases
+                        bool expected = false;
+                        if (rollbackPerformed.compare_exchange_strong(expected, true)) {
+                            @try {
+                                [StallionSlotManager rollbackStage];
+                            } @catch (NSException *e) { }
+                        }
+                    }
+                }
+                
+                // Delete marker
+                [StallionFileManager deleteFileOrFolderSilently:markerPath];
+                hasProcessedNativeCrashMarker.store(true);
+            }
+        }
+    } @catch (NSException *e) { }
 }
 

package/ios/main/StallionSlotManager.m

@@ -74,7 +74,7 @@
       NSString *newSlotPath = [NSString stringWithFormat:@"%@/%@/%@", baseFolderPath, StallionObjConstants.prod_directory, StallionObjConstants.new_folder_slot];
       NSString *stableSlotPath = [NSString stringWithFormat:@"%@/%@/%@", baseFolderPath, StallionObjConstants.prod_directory, StallionObjConstants.stable_folder_slot];
 
-      [StallionFileManager copyFileOrDirectoryFrom:newSlotPath to:stableSlotPath];
+      [StallionFileManager moveFileFrom:newSlotPath to:stableSlotPath];
 
         NSString *newReleaseHash = stateManager.stallionMeta.prodNewHash;
         [stateManager.stallionMeta setProdStableHash:newReleaseHash];

package/ios/main/StallionStateManager.m

@@ -44,6 +44,9 @@ static StallionStateManager *_instance = nil;
         _isMounted = NO;
         _pendingReleaseUrl = @"";
         _pendingReleaseHash = @"";
+        
+        // Reset mount state on initialization (ensures mount marker file is deleted for new session)
+        [self setIsMounted:NO];
     }
     return self;
 }
@@ -70,6 +73,32 @@ static StallionStateManager *_instance = nil;
     [self syncStallionMeta];
 }
 
+- (void)setIsMounted:(BOOL)isMounted {
+    _isMounted = isMounted;
+    // Write mount state to a simple file that signal handler can read (async-signal-safe)
+    NSString *filesDir = self.stallionConfig.filesDirectory;
+    NSString *mountMarkerPath = [NSString stringWithFormat:@"%@/stallion_mount.marker", filesDir];
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    
+    if (isMounted) {
+        // Create file to indicate mounted (file existence = mounted)
+        @try {
+            [fileManager createFileAtPath:mountMarkerPath contents:nil attributes:nil];
+        } @catch (NSException *e) {
+            // Silently ignore errors
+        }
+    } else {
+        // Delete file to indicate not mounted (no file = not mounted)
+        @try {
+            if ([fileManager fileExistsAtPath:mountMarkerPath]) {
+                [fileManager removeItemAtPath:mountMarkerPath error:nil];
+            }
+        } @catch (NSException *e) {
+            // Silently ignore errors
+        }
+    }
+}
+
 #pragma mark - Local Storage Methods
 
 - (NSString *)getStringForKey:(NSString *)key defaultValue:(NSString *)defaultValue {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-stallion",
-  "version": "2.3.0-alpha.5",
+  "version": "2.3.0-alpha.7",
   "description": "Offical React Native SDK for Stallion",
   "main": "index",
   "types": "types/index.d.ts",

package/src/main/utils/ErrorBoundary.js

@@ -11,7 +11,8 @@ class ErrorBoundary extends Component {
   constructor(props) {
     super(props);
     this.state = {
-      errorText: null
+      errorText: null,
+      originalError: null
     };
     this.continueCrash = this.continueCrash.bind(this);
   }
@@ -40,11 +41,6 @@ class ErrorBoundary extends Component {
     // Mark that a crash has occurred
     setCrashOccurred();
 
-    // Always populate state with error information
-    this.setState({
-      errorText: errorString
-    });
-
     // Get meta to determine behavior
     const meta = await getStallionMetaNative();
 
@@ -53,10 +49,22 @@ class ErrorBoundary extends Component {
       requestAnimationFrame(() => {
         throw error;
       });
+    } else {
+      // Store both error string and original error for STAGE mode
+      this.setState({
+        errorText: errorString,
+        originalError: error
+      });
     }
   }
   continueCrash() {
-    throw new Error(this.state.errorText || '');
+    // Re-throw original error if available to preserve full context (stack trace, name, etc.)
+    // Fallback to new error with error text if original is not available
+    if (this.state.originalError) {
+      throw this.state.originalError;
+    } else {
+      throw new Error(this.state.errorText || '');
+    }
   }
   render() {
     if (this.state.errorText) {

package/src/main/utils/ErrorBoundary.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","Component","View","StyleSheet","Text","ScrollView","SafeAreaView","Header","ButtonFullWidth","getStallionMetaNative","setCrashOccurred","HEADER_TITLE","STALLION_EB_BTN_TXT","STALLION_EB_INFO","STD_MARGIN","COLORS","SWITCH_STATES","ErrorBoundary","constructor","props","state","errorText","continueCrash","bind","componentDidCatch","error","errorInfo","errorParts","name","push","message","cause","String","stack","componentStack","errorString","length","join","console","setState","meta","switchState","STAGE","requestAnimationFrame","Error","render","createElement","style","styles","ebContainer","title","ebContentContainer","ebInfoTextContainer","ebInfoText","buttonText","onPress","ebScrollContainer","contentContainerStyle","ebScrollContentContainer","ebErrorText","children","create","flex","flexDirection","justifyContent","alignItems","paddingHorizontal","width","marginVertical","flexGrow","textAlign","backgroundColor","black7","color","white"],"sourceRoot":"../../../../src","sources":["main/utils/ErrorBoundary.tsx"],"mappings":"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"}
+{"version":3,"names":["React","Component","View","StyleSheet","Text","ScrollView","SafeAreaView","Header","ButtonFullWidth","getStallionMetaNative","setCrashOccurred","HEADER_TITLE","STALLION_EB_BTN_TXT","STALLION_EB_INFO","STD_MARGIN","COLORS","SWITCH_STATES","ErrorBoundary","constructor","props","state","errorText","originalError","continueCrash","bind","componentDidCatch","error","errorInfo","errorParts","name","push","message","cause","String","stack","componentStack","errorString","length","join","console","meta","switchState","STAGE","requestAnimationFrame","setState","Error","render","createElement","style","styles","ebContainer","title","ebContentContainer","ebInfoTextContainer","ebInfoText","buttonText","onPress","ebScrollContainer","contentContainerStyle","ebScrollContentContainer","ebErrorText","children","create","flex","flexDirection","justifyContent","alignItems","paddingHorizontal","width","marginVertical","flexGrow","textAlign","backgroundColor","black7","color","white"],"sourceRoot":"../../../../src","sources":["main/utils/ErrorBoundary.tsx"],"mappings":"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"}

package/types/main/utils/ErrorBoundary.d.ts

@@ -3,6 +3,7 @@ interface IErrorBoundaryProps {
 }
 interface IErrorBoundaryState {
     errorText?: string | null;
+    originalError?: Error | null;
 }
 declare class ErrorBoundary extends Component<IErrorBoundaryProps, IErrorBoundaryState> {
     constructor(props: IErrorBoundaryProps);

package/types/main/utils/ErrorBoundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ErrorBoundary.d.ts","sourceRoot":"","sources":["../../../../src/main/utils/ErrorBoundary.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAiBzC,UAAU,mBAAmB;CAAG;AAChC,UAAU,mBAAmB;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,cAAM,aAAc,SAAQ,SAAS,CACnC,mBAAmB,EACnB,mBAAmB,CACpB;gBACa,KAAK,EAAE,mBAAmB;IAQhC,iBAAiB,CACrB,KAAK,EAAE,KAAK,EACZ,SAAS,CAAC,EAAE,KAAK,CAAC,SAAS,GAC1B,OAAO,CAAC,IAAI,CAAC;IA+ChB,aAAa;IAGb,MAAM;CAyBP;AAED,eAAe,aAAa,CAAC"}
+{"version":3,"file":"ErrorBoundary.d.ts","sourceRoot":"","sources":["../../../../src/main/utils/ErrorBoundary.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAiBzC,UAAU,mBAAmB;CAAG;AAChC,UAAU,mBAAmB;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,aAAa,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B;AAED,cAAM,aAAc,SAAQ,SAAS,CACnC,mBAAmB,EACnB,mBAAmB,CACpB;gBACa,KAAK,EAAE,mBAAmB;IAShC,iBAAiB,CACrB,KAAK,EAAE,KAAK,EACZ,SAAS,CAAC,EAAE,KAAK,CAAC,SAAS,GAC1B,OAAO,CAAC,IAAI,CAAC;IAgDhB,aAAa;IASb,MAAM;CAyBP;AAED,eAAe,aAAa,CAAC"}