@rejourneyco/react-native 1.0.1 → 1.0.3

package/ios/Core/Rejourney.mm

@@ -46,6 +46,7 @@
 #import <UIKit/UIKit.h>
 #import <mach/mach_time.h>
 #import <sys/sysctl.h>
+#import <sys/utsname.h>
 
 static uint64_t _rj_constructorMachTime = 0;
 static NSTimeInterval _rj_constructorWallTimeMs = 0;
@@ -248,22 +249,33 @@ RCT_EXPORT_MODULE()
     didDecideSample = YES;
   }
 
-  BOOL shouldRecord = self.recordingEnabledByConfig && self.sessionSampled;
-  self.remoteRecordingEnabled = shouldRecord;
+  // Decouple video recording from session active state.
+  // We want to record video ONLY if:
+  // 1. Config says recording is enabled (remote toggles)
+  // 2. Sample rate allows it
+  //
+  // NOTE: Even if shouldRecordVideo is NO, the session remains active
+  // (isRecording=YES) and events are still observed and uploaded ("Data-Only
+  // Mode").
+  BOOL shouldRecordVideo = self.recordingEnabledByConfig && self.sessionSampled;
+  self.remoteRecordingEnabled = shouldRecordVideo;
 
   if (self.captureEngine) {
-    self.captureEngine.uploadsEnabled = shouldRecord;
-    if (!shouldRecord && self.captureEngine.isRecording) {
+    self.captureEngine.uploadsEnabled = shouldRecordVideo;
+    if (!shouldRecordVideo && self.captureEngine.isRecording) {
+      // Stop video capture pipeline to save resources, but keep session alive
       [self.captureEngine stopSession];
     }
   }
 
   if (didDecideSample && self.recordingEnabledByConfig &&
       !self.sessionSampled) {
-    RJLogWarning(@"Session skipped by sample rate (%ld%%)", (long)clampedRate);
+    RJLogInfo(@"Session sampled out for video (%ld%%) - entering Data-Only "
+              @"Mode (Events enabled, Video disabled)",
+              (long)clampedRate);
   }
 
-  return shouldRecord;
+  return shouldRecordVideo;
 }
 
 - (void)ensureFullyInitialized {
@@ -608,6 +620,34 @@ RCT_EXPORT_METHOD(debugTriggerANR : (double)durationMs) {
   });
 }
 
+RCT_EXPORT_METHOD(getDeviceInfo : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  NSMutableDictionary *info = [NSMutableDictionary new];
+
+  // Model
+  struct utsname systemInfo;
+  uname(&systemInfo);
+  NSString *modelCode = [NSString stringWithCString:systemInfo.machine
+                                           encoding:NSUTF8StringEncoding];
+  info[@"model"] = modelCode ?: [[UIDevice currentDevice] model];
+
+  info[@"brand"] = @"Apple";
+  info[@"systemName"] = [[UIDevice currentDevice] systemName];
+  info[@"systemVersion"] = [[UIDevice currentDevice] systemVersion];
+  info[@"bundleId"] = [[NSBundle mainBundle] bundleIdentifier] ?: @"";
+  info[@"appVersion"] =
+      [[NSBundle mainBundle]
+          objectForInfoDictionaryKey:@"CFBundleShortVersionString"]
+          ?: @"";
+  info[@"buildNumber"] =
+      [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleVersion"]
+          ?: @"";
+  info[@"isTablet"] = @([[UIDevice currentDevice] userInterfaceIdiom] ==
+                        UIUserInterfaceIdiomPad);
+
+  resolve(info);
+}
+
 RCT_EXPORT_METHOD(getSessionId : (RCTPromiseResolveBlock)
                       resolve reject : (RCTPromiseRejectBlock)reject) {
   NSString *sessionId = self.currentSessionId;
@@ -647,10 +687,7 @@ RCT_EXPORT_METHOD(stopSession : (RCTPromiseResolveBlock)
 
       NSString *sessionId = self.currentSessionId ?: @"";
 
-      // CRITICAL: Compute background time at the moment we end the session.
-      // When a session ends while the app is in background (e.g. max duration),
-      // we must include the ongoing background duration, otherwise the backend
-      // will think the entire wall-clock session duration is playable.
+    
       NSTimeInterval totalBgTimeMs = 0;
       if (self.lifecycleManager) {
         totalBgTimeMs = self.lifecycleManager.totalBackgroundTimeMs;
@@ -947,7 +984,6 @@ RCT_EXPORT_METHOD(setUserIdentity : (NSString *)userId resolve : (
     @try {
       NSString *safeUserId = userId.length > 0 ? userId : @"anonymous";
 
-      // KEY CHANGE: Persist directly to NSUserDefaults (Native Storage)
       [[NSUserDefaults standardUserDefaults] setObject:safeUserId
                                                 forKey:@"rj_user_identity"];
       [[NSUserDefaults standardUserDefaults] synchronize];
@@ -960,13 +996,11 @@ RCT_EXPORT_METHOD(setUserIdentity : (NSString *)userId resolve : (
       RJLogDebug(@"User identity updated and persisted: %@", safeUserId);
 
       if (self.isRecording) {
-        // Log event for tracking
         NSMutableDictionary *event = [NSMutableDictionary new];
         event[@"type"] = @"user_identity_changed";
         event[@"timestamp"] = @([RJWindowUtils currentTimestampMillis]);
         event[@"userId"] = safeUserId;
 
-        // Helper to log event safely
         if (self.eventBuffer) {
           [self.eventBuffer appendEvent:event];
         }
@@ -1008,17 +1042,15 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
     return;
   }
 
-  // Throttle scroll events to avoid spamming the main thread/logs
   if ([gestureType hasPrefix:@"scroll"]) {
     static NSTimeInterval lastScrollLogTime = 0;
     NSTimeInterval now = CACurrentMediaTime();
-    if (now - lastScrollLogTime < 0.5) { // 500ms throttle
+    if (now - lastScrollLogTime < 0.5) {
       return;
     }
     lastScrollLogTime = now;
   }
 
-  // Move ALL processing to the background state queue to unblock Main Thread
   dispatch_async(self.stateQueue, ^{
     @try {
       NSMutableDictionary *details =
@@ -1030,18 +1062,8 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
             @"targetLabel" : targetLabel ?: [NSNull null]
           }];
 
-      // Log internal event (already on stateQueue, so safe)
-      // We call a simpler version that assumes we are already on background or
-      // handles it Actually logEventInternal dispatches TO stateQueue. Since we
-      // are ON stateQueue, we can call a direct helper or just logEventInternal
-      // (it will just dispatch_async again which is fine) But to be cleaner,
-      // let's just use logEventInternal but ensuring we don't do main thread
-      // dictionary work above. We moved the dictionary creation HERE
-      // (background).
-
       [self logEventInternal:RJEventTypeGesture details:[details copy]];
 
-      // Notify engine on main thread (it's lightweight)
       dispatch_async(dispatch_get_main_queue(), ^{
         if (self.captureEngine) {
           [self.captureEngine notifyGesture:gestureType];
@@ -1111,7 +1133,7 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
       registerDeviceWithProjectKey:publicKey
                           bundleId:bundleId
                           platform:@"ios"
-                        sdkVersion:@"1.0.0"
+                        sdkVersion:RJSDKVersion
                             apiUrl:apiUrl
                         completion:^(BOOL success, NSString *credId,
                                      NSError *error) {
@@ -1123,11 +1145,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
                             RJLogError(@"Device registration failed: %@",
                                        error);
 
-                            // SECURITY: Handle specific error codes
-                            // 403 = Bundle ID mismatch or forbidden - PERMANENT
-                            // failure 404 = Project not found - could be
-                            // temporary, retry Other = Network/transient -
-                            // retry
                             if (error.code == 403) {
                               RJLogError(@"SECURITY: Bundle ID mismatch or "
                                          @"access forbidden. "
@@ -1136,9 +1153,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
                               strongSelf.authPermanentlyFailed = YES;
                               [strongSelf handleAuthenticationFailure:error];
                             } else {
-                              // For 404 and other errors, schedule retry with
-                              // exponential backoff Recording continues locally
-                              // - events queued for later upload
                               [strongSelf scheduleAuthRetryWithError:error
                                                            publicKey:publicKey
                                                               apiUrl:apiUrl];
@@ -1146,7 +1160,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
                           } else {
                             RJLogDebug(@"Device registered: %@", credId);
 
-                            // Auth succeeded - reset retry state
                             [strongSelf resetAuthRetryState];
 
                             [strongSelf
@@ -1161,21 +1174,16 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
 - (void)handleAuthenticationFailure:(NSError *)error {
   RJLogError(@"Authentication failure - stopping recording. Error: %@", error);
 
-  // Stop recording to prevent data accumulation that can't be uploaded
   dispatch_async(dispatch_get_main_queue(), ^{
     if (self.isRecording) {
       self.isRecording = NO;
 
-      // Stop capture engine
       if (self.captureEngine) {
         [self.captureEngine stopSession];
       }
 
-      // Clear auth data so next attempt starts fresh
       [[RJDeviceAuthManager sharedManager] clearAllAuthData];
 
-      // Notify JS layer about the failure (if bridge is available)
-      // This allows the app to handle the error (e.g., show user message)
       @try {
         if (self.bridge) {
           [self.bridge enqueueJSCall:@"RCTDeviceEventEmitter"
@@ -1202,22 +1210,18 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
 - (void)scheduleAuthRetryWithError:(NSError *)error
                          publicKey:(NSString *)publicKey
                             apiUrl:(NSString *)apiUrl {
-  // Check if already permanently failed (403 security error)
   if (self.authPermanentlyFailed) {
     RJLogWarning(@"Auth permanently failed - not scheduling retry");
     return;
   }
 
-  // Increment retry count
   self.authRetryCount++;
 
-  // Check max retries
   if (self.authRetryCount > RJ_MAX_AUTH_RETRIES) {
     RJLogError(@"Auth failed after %ld retries. Recording continues locally, "
                @"events will be uploaded when auth succeeds.",
                (long)RJ_MAX_AUTH_RETRIES);
 
-    // Notify JS but DON'T stop recording - events queue locally
     dispatch_async(dispatch_get_main_queue(), ^{
       @try {
         if (self.bridge) {
@@ -1234,18 +1238,15 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
                           completion:nil];
         }
       } @catch (NSException *exception) {
-        // Ignore JS notification failures
       }
     });
 
-    // Schedule a much longer retry (5 minutes) to try again later
     [self scheduleBackgroundAuthRetryAfter:300.0
                                  publicKey:publicKey
                                     apiUrl:apiUrl];
     return;
   }
 
-  // Calculate exponential backoff delay: 2, 4, 8, 16, 32... capped at 60s
   NSTimeInterval delay =
       MIN(RJ_AUTH_RETRY_BASE_DELAY * pow(2, self.authRetryCount - 1),
           RJ_AUTH_RETRY_MAX_DELAY);
@@ -1263,7 +1264,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
 - (void)scheduleBackgroundAuthRetryAfter:(NSTimeInterval)delay
                                publicKey:(NSString *)publicKey
                                   apiUrl:(NSString *)apiUrl {
-  // Cancel any existing retry timer
   if (self.authRetryTimer) {
     [self.authRetryTimer invalidate];
     self.authRetryTimer = nil;
@@ -1296,14 +1296,11 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
 
   RJLogInfo(@"Retrying auth (attempt %ld)...", (long)(self.authRetryCount + 1));
 
-  // After 2 failed attempts, clear cached auth data and re-register fresh
-  // This handles expired/corrupted tokens or server-side revocations
   if (self.authRetryCount >= 2) {
     RJLogInfo(@"Clearing cached auth data and re-registering fresh...");
     [[RJDeviceAuthManager sharedManager] clearAllAuthData];
   }
 
-  // Re-attempt device auth setup
   [self setupDeviceAuthWithPublicKey:publicKey apiUrl:apiUrl];
 }
 
@@ -1340,12 +1337,10 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
       return;
     }
 
-    // Handle security errors (403 = forbidden/mismatch, 404 = not found)
     if ((error.code == 403 || error.code == 404) &&
         [error.domain isEqualToString:@"RJDeviceAuth"]) {
 
       if (!isRetry) {
-        // First failure - try re-registration
         RJLogDebug(@"Device auth invalid (%ld), attempting re-registration...",
                    (long)error.code);
         NSString *bundleId =
@@ -1356,7 +1351,7 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
             registerDeviceWithProjectKey:publicKey
                                 bundleId:bundleId
                                 platform:@"ios"
-                              sdkVersion:@"1.0.0"
+                              sdkVersion:RJSDKVersion
                                   apiUrl:apiUrl
                               completion:^(BOOL retrySuccess, NSString *credId,
                                            NSError *retryError) {
@@ -1372,8 +1367,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
                                                                         apiUrl
                                                                    isRetry:YES];
                                 } else {
-                                  // Re-registration also failed - this is a
-                                  // security error
                                   RJLogError(@"Re-registration failed: %@",
                                              retryError);
                                   if (retryError.code == 403 ||
@@ -1384,12 +1377,10 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
                                 }
                               }];
       } else {
-        // Already retried - this is a persistent security error
         RJLogError(@"Token fetch failed after retry: %@", error);
         [strongSelf handleAuthenticationFailure:error];
       }
     } else {
-      // Network or other transient errors
       RJLogWarning(@"Failed to get upload token (transient): %@", error);
     }
   }];
@@ -1557,7 +1548,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   if (self.isShuttingDown || !eventType)
     return;
 
-  // Log gesture events specifically for debugging
   if ([eventType isEqualToString:@"gesture"]) {
     NSString *gestureType = details[@"gestureType"] ?: @"unknown";
     RJLogInfo(
@@ -1774,9 +1764,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   });
 }
 
-/// Flush data with option to end session or keep it alive for resumption.
-/// @param isFinal If YES, ends the session on backend. If NO, just uploads
-/// pending data.
 - (void)flushDataWithCompletion:(RJCompletionHandler)completion
                         isFinal:(BOOL)isFinal {
 
@@ -1834,7 +1821,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
               return;
             }
 
-            // For non-final flushes, skip promotion evaluation and just upload
             if (!isFinal) {
               RJLogInfo(
                   @"[RJ-FLUSH] Non-final background flush - uploading %lu "
@@ -1915,13 +1901,10 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   }
 }
 
-/// Convenience method for final flush (ends session).
 - (void)flushAllDataWithCompletion:(RJCompletionHandler)completion {
   [self flushDataWithCompletion:completion isFinal:YES];
 }
 
-/// Flush pending data for background transition without ending the session.
-/// Used when app goes to background but may return quickly.
 - (void)flushDataForBackgroundWithCompletion:(RJCompletionHandler)completion {
   [self flushDataWithCompletion:completion isFinal:NO];
 }
@@ -1960,7 +1943,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   if (self.isRecording) {
     RJLogDebug(@"[KEYBOARD] Keyboard shown (height=%.0f)",
                keyboardFrame.size.height);
-    // Include keyboard height so web UI can render overlay
     [self logEventInternal:RJEventTypeKeyboardShow
                    details:@{
                      @"keyboardHeight" : @(keyboardFrame.size.height),
@@ -2020,9 +2002,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   @try {
     [self stopBatchUploadTimer];
 
-    // CRITICAL: Sync accumulated background time to uploadManager BEFORE any
-    // flush This ensures if the session ends during background, the correct
-    // time is included
     if (self.uploadManager && self.lifecycleManager) {
       NSTimeInterval currentBgTime =
           self.lifecycleManager.totalBackgroundTimeMs;
@@ -2032,14 +2011,10 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
           currentBgTime);
     }
 
-    // Log background event FIRST and SYNCHRONOUSLY so it's included in the
-    // flush This must happen before we pause capture or start the flush
     NSMutableDictionary *bgEvent =
         [NSMutableDictionary dictionaryWithCapacity:3];
     bgEvent[@"type"] = RJEventTypeAppBackground;
     bgEvent[@"timestamp"] = @([RJWindowUtils currentTimestampMillis]);
-
-    // Add directly to session events synchronously
     [self performStateSync:^{
       if (self.sessionEvents) {
         [self.sessionEvents addObject:bgEvent];
@@ -2049,17 +2024,12 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
       }
     }];
 
-    // Also add to event buffer for persistence
     if (self.eventBuffer) {
       [self.eventBuffer appendEvent:bgEvent];
     }
 
     if (self.captureEngine) {
       @try {
-        // Use ASYNCHRONOUS pause for backgrounding.
-        // The encoder now implements internal UIBackgroundTask protection, so
-        // it will finish finalizing the MP4 on a background queue without
-        // locking the UI.
         RJLogInfo(@"[RJ-VIDEO] Pausing video capture for background (ASYNC)");
         [self.captureEngine pauseVideoCapture];
         RJLogInfo(@"[RJ-VIDEO] Video capture pause initiated");
@@ -2074,9 +2044,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
           beginBackgroundTaskWithName:@"RejourneySessionFlush"];
     }
 
-    // Use non-final flush for background - session may resume if user returns
-    // quickly This avoids calling session/end which would prevent frame capture
-    // after returning
     RJLogInfo(@"[RJ-FLUSH] Starting non-final background flush (session will "
               @"resume if user returns)");
     [self flushDataForBackgroundWithCompletion:^(BOOL success) {
@@ -2129,13 +2096,9 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   @try {
     [self stopBatchUploadTimer];
 
-    // CRITICAL: Calculate and sync background time before ending session
-    // If we're being terminated while in background, we need to include
-    // the current background duration in the session's total background time
     if (self.uploadManager && self.lifecycleManager) {
       NSTimeInterval totalBgTime = self.lifecycleManager.totalBackgroundTimeMs;
 
-      // If we're currently in background, add the ongoing duration
       if (self.lifecycleManager.isInBackground &&
           self.lifecycleManager.backgroundEntryTime > 0) {
         NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
@@ -2155,15 +2118,12 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
     }
 
     if (self.captureEngine) {
-      // Use SYNCHRONOUS stop to ensure segment is finished and upload is
-      // triggered before we try to upload events. This prevents video segments
-      // from being lost when app is terminated.
+
       RJLogInfo(@"[RJ-TERMINATE] Stopping capture engine synchronously");
       [self.captureEngine stopSessionSync];
       RJLogInfo(@"[RJ-TERMINATE] Capture engine stopped");
     }
 
-    // Add terminated event SYNCHRONOUSLY before we copy events
     NSMutableDictionary *terminateEvent =
         [NSMutableDictionary dictionaryWithCapacity:3];
     terminateEvent[@"type"] = RJEventTypeAppTerminated;
@@ -2192,9 +2152,9 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
 
     if (self.uploadManager && events.count > 0) {
       @try {
-        [self.uploadManager synchronousUploadWithEvents:events ?: @[]];
+        [self.uploadManager persistTerminationEvents:events ?: @[]];
       } @catch (NSException *e) {
-        RJLogWarning(@"Terminate upload failed: %@", e);
+        RJLogWarning(@"Terminate persistence failed: %@", e);
       }
     }
   } @catch (NSException *exception) {
@@ -2219,7 +2179,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   @try {
     NSTimeInterval bgTimeMs = self.lifecycleManager.totalBackgroundTimeMs;
 
-    // Keep local state in sync so stopSession/flush paths can rely on it.
     self.totalBackgroundTimeMs = bgTimeMs;
 
     if (self.uploadManager) {
@@ -2259,16 +2218,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   [self handleSessionTimeout:backgroundDuration currentTime:currentTime];
 }
 
-/// Handle session timeout after extended background period.
-/// This cleanly ends the old session and starts a fresh one.
-///
-/// Flow:
-/// 1. Capture final background time from lifecycle manager
-/// 2. Stop timers and capture engine for old session
-/// 3. Synchronously end the old session with correct background time
-/// 4. Create new session ID and reset all state
-/// 5. Start capture for new session
-/// 6. Trigger immediate upload to register new session
 - (void)handleSessionTimeout:(NSTimeInterval)backgroundDuration
                  currentTime:(NSTimeInterval)currentTime {
   RJLogInfo(
@@ -2282,8 +2231,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
     RJLogInfo(@"[RJ-SESSION-TIMEOUT] === ENDING OLD SESSION: %@ ===",
               oldSessionId);
 
-    // ========== STEP 1: Capture background time BEFORE any state changes
-    // ==========
     NSTimeInterval totalBackgroundMs = 0;
     if (self.lifecycleManager) {
       totalBackgroundMs = self.lifecycleManager.totalBackgroundTimeMs;
@@ -2292,7 +2239,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
           totalBackgroundMs);
     }
 
-    // ========== STEP 2: Stop all capture/timers for old session ==========
     [self stopBatchUploadTimer];
     [self stopDurationLimitTimer];
 
@@ -2305,14 +2251,10 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
       }
     }
 
-    // ========== STEP 3: End old session SYNCHRONOUSLY with correct background
-    // time ==========
     if (wasRecording && self.uploadManager && oldSessionId.length > 0 &&
         ![oldSessionId isEqualToString:@"none"]) {
-      // Set background time on upload manager
       self.uploadManager.totalBackgroundTimeMs = totalBackgroundMs;
 
-      // Get current events for final upload
       __block NSArray<NSDictionary *> *finalEvents = nil;
       [self performStateSync:^{
         finalEvents = [self.sessionEvents copy];
@@ -2322,18 +2264,15 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
                 @"bgTime=%.0fms",
                 (unsigned long)finalEvents.count, totalBackgroundMs);
 
-      // Synchronous upload and session end
       if (finalEvents.count > 0) {
         [self.uploadManager synchronousUploadWithEvents:finalEvents];
       } else {
-        // Even with no events, end the session to record background time
         [self.uploadManager endSessionSync];
       }
 
       RJLogInfo(@"[RJ-SESSION-TIMEOUT] Old session %@ ended", oldSessionId);
     }
 
-    // ========== STEP 4: Reset ALL state for new session ==========
     RJLogInfo(@"[RJ-SESSION-TIMEOUT] === STARTING NEW SESSION ===");
 
     __block NSString *newSessionId = nil;
@@ -2343,8 +2282,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
       self.sessionStartTime = currentTime;
       self.totalBackgroundTimeMs = 0;
       [self.sessionEvents removeAllObjects];
-
-      // Persist for crash recovery
       [[NSUserDefaults standardUserDefaults]
           setObject:newSessionId
              forKey:@"rj_current_session_id"];
@@ -2353,7 +2290,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
 
     RJLogInfo(@"[RJ-SESSION-TIMEOUT] New session ID: %@", newSessionId);
 
-    // Reset upload manager for new session
     if (self.uploadManager) {
       @try {
         [self.uploadManager resetForNewSession];
@@ -2365,7 +2301,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
       self.uploadManager.sessionStartTime = currentTime;
       self.uploadManager.totalBackgroundTimeMs = 0;
 
-      // Preserve user identity
       if (!self.userId) {
         self.userId = [[NSUserDefaults standardUserDefaults]
             stringForKey:@"rj_user_identity"];
@@ -2373,17 +2308,14 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
       self.uploadManager.userId = self.userId ?: @"anonymous";
     }
 
-    // Reset lifecycle manager background tracking
     if (self.lifecycleManager) {
       [self.lifecycleManager resetBackgroundTime];
       self.lifecycleManager.isRecording = YES;
     }
 
-    // Reset event buffer for new session - recreate since sessionId is readonly
     if (self.eventBuffer) {
       [self.eventBuffer clearAllEvents];
     }
-    // Create new event buffer for new session (sessionId is readonly)
     NSString *pendingPath = self.eventBuffer.pendingRootPath;
     if (pendingPath.length == 0) {
       pendingPath =
@@ -2394,7 +2326,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
     self.eventBuffer = [[RJEventBuffer alloc] initWithSessionId:newSessionId
                                                 pendingRootPath:pendingPath];
 
-    // ========== STEP 5: Start capture for new session ==========
     [self resetSamplingDecision];
     self.remoteRecordingEnabled = self.recordingEnabledByConfig;
     if (self.captureEngine) {
@@ -2417,20 +2348,14 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
     }
 
     self.isRecording = YES;
-
-    // Verify touch tracking
     RJTouchInterceptor *touchInterceptor = [RJTouchInterceptor sharedInstance];
     if (touchInterceptor && !touchInterceptor.isTrackingEnabled) {
       RJLogInfo(@"[RJ-SESSION-TIMEOUT] Re-enabling touch tracking");
       [self setupTouchTracking];
     }
-
-    // Start timers for new session
     [self startBatchUploadTimer];
     [self startDurationLimitTimer];
 
-    // ========== STEP 6: Log session_start and trigger immediate upload
-    // ==========
     NSMutableDictionary *sessionStartEvent = [NSMutableDictionary dictionary];
     sessionStartEvent[@"type"] = RJEventTypeSessionStart;
     sessionStartEvent[@"timestamp"] = @([RJWindowUtils currentTimestampMillis]);
@@ -2447,7 +2372,6 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
       [self.eventBuffer appendEvent:sessionStartEvent];
     }
 
-    // Immediate upload to register session with backend
     dispatch_after(
         dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)),
         dispatch_get_main_queue(), ^{

package/ios/Network/RJDeviceAuthManager.m

@@ -857,10 +857,8 @@ static const NSInteger RJ_AUTH_MAX_CONSECUTIVE_FAILURES = 10;
     return;
   }
   
-  // Check cooldown after consecutive failures to prevent flooding
   NSTimeInterval now = [[NSDate date] timeIntervalSince1970];
   if (self.consecutiveFailures > 0 && self.lastFailedRegistrationTime > 0) {
-    // Exponential backoff: 5s, 10s, 20s, 40s... up to 5 minutes
     NSTimeInterval cooldown = MIN(
       RJ_AUTH_COOLDOWN_BASE_SECONDS * pow(2, self.consecutiveFailures - 1),
       RJ_AUTH_COOLDOWN_MAX_SECONDS

package/ios/Network/RJUploadManager.h

@@ -180,6 +180,14 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (BOOL)synchronousUploadWithEvents:(NSArray<NSDictionary *> *)events;
 
+/**
+ * Persists events to disk for termination, skipping network upload.
+ * Use this in appWillTerminate to avoid watchdog kills.
+ *
+ * @param events Array of event dictionaries.
+ */
+- (void)persistTerminationEvents:(NSArray<NSDictionary *> *)events;
+
 /**
  * Uploads a crash report to the dashboard.
  *