@rejourneyco/react-native 1.0.0 → 1.0.1

package/ios/Capture/RJCaptureHeuristics.m

@@ -20,7 +20,7 @@ static const NSTimeInterval kRJQuietScrollSeconds = 0.2;
 static const NSTimeInterval kRJQuietBounceSeconds = 0.2;
 static const NSTimeInterval kRJQuietRefreshSeconds = 0.22;
 static const NSTimeInterval kRJQuietMapSeconds = 0.55;
-static const NSTimeInterval kRJQuietTransitionSeconds = 0.2;
+static const NSTimeInterval kRJQuietTransitionSeconds = 0.1;
 static const NSTimeInterval kRJQuietKeyboardSeconds = 0.25;
 static const NSTimeInterval kRJQuietAnimationSeconds = 0.25;
 
@@ -204,7 +204,8 @@ typedef struct {
 
 - (void)recordTouchEventAtTime:(NSTimeInterval)time {
   self.lastTouchTime = time;
-  [self scheduleBonusCaptureAfterDelay:kRJBonusInteractionDelaySeconds now:time];
+  [self scheduleBonusCaptureAfterDelay:kRJBonusInteractionDelaySeconds
+                                   now:time];
 }
 
 - (void)recordInteractionEventAtTime:(NSTimeInterval)time {
@@ -221,12 +222,11 @@ typedef struct {
 
 - (void)recordNavigationEventAtTime:(NSTimeInterval)time {
   self.lastTransitionTime = time;
-  [self scheduleBonusCaptureAfterDelay:kRJBonusTransitionDelaySeconds
-                                   now:time];
+  [self scheduleBonusCaptureAfterDelay:kRJBonusTransitionDelaySeconds now:time];
 }
 
 - (void)recordRenderedSignature:(nullable NSString *)signature
-                          atTime:(NSTimeInterval)time {
+                         atTime:(NSTimeInterval)time {
   self.lastRenderedSignature = signature.length > 0 ? signature : nil;
   self.lastRenderedTime = time;
   if (self.pendingKeyframes > 0) {
@@ -262,8 +262,8 @@ typedef struct {
     }
     self.lastObservedSignatureTime = now;
     self.lastSignatureChurnTime = now;
-    self.lastObservedSignature = currentSignature.length > 0 ? currentSignature
-                                                             : nil;
+    self.lastObservedSignature =
+        currentSignature.length > 0 ? currentSignature : nil;
   } else if (self.lastSignatureChurnTime > 0 &&
              (now - self.lastSignatureChurnTime) >
                  kRJSignatureChurnWindowSeconds) {
@@ -296,15 +296,15 @@ typedef struct {
   }
 
   [self updateScrollActiveState:scanResult.scrollActive
-                    refreshActive:scanResult.refreshActive
-                         mapActive:scanResult.mapActive
-                               now:now];
+                  refreshActive:scanResult.refreshActive
+                      mapActive:scanResult.mapActive
+                            now:now];
 
   BOOL blockingAnimation = NO;
   if (scanResult.hasAnyAnimations) {
     self.lastAnimationAreaRatio = scanResult.animationAreaRatio;
-    blockingAnimation = (scanResult.animationAreaRatio >=
-                         kRJAnimationSmallAreaAllowed);
+    blockingAnimation =
+        (scanResult.animationAreaRatio >= kRJAnimationSmallAreaAllowed);
   } else {
     self.lastAnimationAreaRatio = 0.0;
   }
@@ -335,88 +335,113 @@ typedef struct {
   [self probeAnimatedViewsAtTime:now];
 }
 
-- (RJCaptureHeuristicsDecision *)decisionForSignature:
-                                    (nullable NSString *)signature
-                                                 now:(NSTimeInterval)now
-                                         hasLastFrame:(BOOL)hasLastFrame {
+- (RJCaptureHeuristicsDecision *)
+    decisionForSignature:(nullable NSString *)signature
+                     now:(NSTimeInterval)now
+            hasLastFrame:(BOOL)hasLastFrame
+              importance:(RJCaptureImportance)importance {
   RJCaptureHeuristicsDecision *decision =
       [[RJCaptureHeuristicsDecision alloc] init];
 
   NSTimeInterval earliestSafeTime = now;
   RJCaptureHeuristicsReason blockerReason = RJCaptureHeuristicsReasonRenderNow;
 
+  // Check importance to potentially bypass heuristics
+  BOOL isUrgent = (importance == RJCaptureImportanceHigh ||
+                   importance == RJCaptureImportanceCritical);
+
   // Active touch/gesture input should be avoided to keep input latency smooth.
-  [self considerBlockerSince:self.lastTouchTime
-               quietInterval:kRJQuietTouchSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferTouch
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  // CRITICAL updates bypass this.
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastTouchTime
+                 quietInterval:kRJQuietTouchSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferTouch
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Scroll motion (dragging or deceleration) is a high-jank period.
-  [self considerBlockerSince:self.lastScrollTime
-               quietInterval:kRJQuietScrollSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferScroll
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  // Even urgent captures should respect scroll to avoid visible hitching,
+  // unless CRITICAL
+  if (importance != RJCaptureImportanceCritical) {
+    [self considerBlockerSince:self.lastScrollTime
+                 quietInterval:kRJQuietScrollSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferScroll
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Rubber-band bounce and inset animations are visually sensitive.
-  [self considerBlockerSince:self.lastBounceTime
-               quietInterval:kRJQuietBounceSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferBounce
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastBounceTime
+                 quietInterval:kRJQuietBounceSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferBounce
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Pull-to-refresh animations should finish before rendering.
-  [self considerBlockerSince:self.lastRefreshTime
-               quietInterval:kRJQuietRefreshSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferRefresh
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastRefreshTime
+                 quietInterval:kRJQuietRefreshSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferRefresh
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Interactive transitions (swipe back, drag-to-dismiss) are hitch-sensitive.
-  [self considerBlockerSince:self.lastTransitionTime
-               quietInterval:kRJQuietTransitionSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferTransition
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  // KEY FIX: Urgent captures (NAVIGATION) must bypass this!
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastTransitionTime
+                 quietInterval:kRJQuietTransitionSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferTransition
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Keyboard frame animations can stutter; wait for settle.
   if (self.keyboardAnimating) {
     self.lastKeyboardTime = now;
   }
-  [self considerBlockerSince:self.lastKeyboardTime
-               quietInterval:kRJQuietKeyboardSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferKeyboard
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastKeyboardTime
+                 quietInterval:kRJQuietKeyboardSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferKeyboard
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Map camera or tile motion is visually obvious; avoid rendering mid-flight.
-  [self considerBlockerSince:self.lastMapTime
-               quietInterval:kRJQuietMapSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferMap
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  // Maps are special; even CRITICAL captures might want to wait for map settle
+  // if possible.
+  if (importance != RJCaptureImportanceCritical) {
+    [self considerBlockerSince:self.lastMapTime
+                 quietInterval:kRJQuietMapSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferMap
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
 
-  if (self.mapSettleUntil > now && self.mapSettleUntil > earliestSafeTime) {
-    earliestSafeTime = self.mapSettleUntil;
-    blockerReason = RJCaptureHeuristicsReasonDeferMap;
+    if (self.mapSettleUntil > now && self.mapSettleUntil > earliestSafeTime) {
+      earliestSafeTime = self.mapSettleUntil;
+      blockerReason = RJCaptureHeuristicsReasonDeferMap;
+    }
   }
 
   // Large-area animations (Lottie, shimmer, etc.) are very noticeable.
-  if (self.animationBlocking) {
+  if (self.animationBlocking && !isUrgent) {
     [self considerBlockerSince:self.lastAnimationTime
                  quietInterval:kRJQuietAnimationSeconds
                            now:now
-                       reason:RJCaptureHeuristicsReasonDeferBigAnimation
-                 earliestTime:&earliestSafeTime
-                 chosenReason:&blockerReason];
+                        reason:RJCaptureHeuristicsReasonDeferBigAnimation
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
   }
 
   if (earliestSafeTime > now) {
@@ -426,26 +451,27 @@ typedef struct {
     return decision;
   }
 
-  BOOL signatureChanged = (signature.length == 0 ||
-                           ![signature isEqualToString:self.lastRenderedSignature]);
+  BOOL signatureChanged =
+      (signature.length == 0 ||
+       ![signature isEqualToString:self.lastRenderedSignature]);
   BOOL stale = (self.lastRenderedTime <= 0 ||
                 (now - self.lastRenderedTime) > self.maxStaleSeconds);
   BOOL bonusDue = (self.bonusCaptureTime > 0 && now >= self.bonusCaptureTime);
-  BOOL keyframeDue = bonusDue && self.pendingKeyframes > 0 &&
-                     (now - self.lastKeyframeRenderTime) >=
-                         kRJKeyframeSpacingSeconds;
+  BOOL keyframeDue =
+      bonusDue && self.pendingKeyframes > 0 &&
+      (now - self.lastKeyframeRenderTime) >= kRJKeyframeSpacingSeconds;
   BOOL staleOnly = stale && hasLastFrame && !signatureChanged && !keyframeDue;
   BOOL suppressStaleRender =
       staleOnly &&
       (self.hasVideoSurface || self.hasWebSurface || self.hasCameraSurface);
 
-  if (suppressStaleRender) {
+  if (suppressStaleRender && !isUrgent) {
     decision.action = RJCaptureHeuristicsActionReuseLast;
     decision.reason = RJCaptureHeuristicsReasonReuseSignatureUnchanged;
     return decision;
   }
 
-  if (!hasLastFrame || signatureChanged || stale || keyframeDue) {
+  if (!hasLastFrame || signatureChanged || stale || keyframeDue || isUrgent) {
     decision.action = RJCaptureHeuristicsActionRenderNow;
     decision.reason = RJCaptureHeuristicsReasonRenderNow;
     return decision;
@@ -516,7 +542,8 @@ typedef struct {
   UIViewController *topVC = [self topViewControllerForWindow:window];
   if (topVC != self.lastTopVC) {
     self.lastTransitionTime = now;
-    [self scheduleBonusCaptureAfterDelay:kRJBonusTransitionDelaySeconds now:now];
+    [self scheduleBonusCaptureAfterDelay:kRJBonusTransitionDelaySeconds
+                                     now:now];
     self.lastTopVC = topVC;
   }
   id<UIViewControllerTransitionCoordinator> coordinator =
@@ -552,7 +579,7 @@ typedef struct {
 #pragma mark - Scroll Tracking
 
 - (void)updateTrackedScrollViews:(NSArray<NSValue *> *)scrollViewPointers
-                              now:(NSTimeInterval)now {
+                             now:(NSTimeInterval)now {
   if (!scrollViewPointers) {
     return;
   }
@@ -563,18 +590,18 @@ typedef struct {
       continue;
     }
     [self evaluateScrollView:scrollView
-                        now:now
-                 scrollActive:NULL
-                refreshActive:NULL];
+                         now:now
+                scrollActive:NULL
+               refreshActive:NULL];
   }
-
 }
 
 - (void)probeScrollViewsAtTime:(NSTimeInterval)now {
   BOOL anyScrollActive = NO;
   BOOL anyRefreshActive = NO;
 
-  NSArray<UIScrollView *> *scrollViews = [[self.scrollSamples keyEnumerator] allObjects];
+  NSArray<UIScrollView *> *scrollViews =
+      [[self.scrollSamples keyEnumerator] allObjects];
   if (!scrollViews) {
     scrollViews = @[];
   }
@@ -583,21 +610,21 @@ typedef struct {
       continue;
     }
     [self evaluateScrollView:scrollView
-                        now:now
-                 scrollActive:&anyScrollActive
-                refreshActive:&anyRefreshActive];
+                         now:now
+                scrollActive:&anyScrollActive
+               refreshActive:&anyRefreshActive];
   }
 
   [self updateScrollActiveState:anyScrollActive
-                    refreshActive:anyRefreshActive
-                         mapActive:self.mapActive
-                               now:now];
+                  refreshActive:anyRefreshActive
+                      mapActive:self.mapActive
+                            now:now];
 }
 
 - (void)evaluateScrollView:(UIScrollView *)scrollView
                        now:(NSTimeInterval)now
-                scrollActive:(BOOL *)scrollActive
-               refreshActive:(BOOL *)refreshActive {
+              scrollActive:(BOOL *)scrollActive
+             refreshActive:(BOOL *)refreshActive {
   RJScrollViewSample *sample = [self.scrollSamples objectForKey:scrollView];
   if (!sample) {
     sample = [[RJScrollViewSample alloc] init];
@@ -609,8 +636,9 @@ typedef struct {
 
   BOOL tracking = scrollView.isTracking || scrollView.isDragging ||
                   scrollView.isDecelerating;
-  BOOL offsetMoved = (fabs(offset.x - sample.contentOffset.x) > kRJScrollEpsilon ||
-                      fabs(offset.y - sample.contentOffset.y) > kRJScrollEpsilon);
+  BOOL offsetMoved =
+      (fabs(offset.x - sample.contentOffset.x) > kRJScrollEpsilon ||
+       fabs(offset.y - sample.contentOffset.y) > kRJScrollEpsilon);
   BOOL zoomMoved = fabs(zoomScale - sample.zoomScale) > kRJZoomEpsilon;
   BOOL isScrolling = tracking || offsetMoved || zoomMoved;
 
@@ -635,8 +663,8 @@ typedef struct {
   }
 
   BOOL refreshVisible = [self isRefreshActiveForScrollView:scrollView
-                                                   offset:offset
-                                                    inset:inset];
+                                                    offset:offset
+                                                     inset:inset];
   if (refreshVisible) {
     // Pull-to-refresh is active or settling.
     self.lastRefreshTime = now;
@@ -660,8 +688,8 @@ typedef struct {
   }
   CGFloat topLimit = -inset.top - kRJScrollEpsilon;
   CGFloat bottomLimit = scrollView.contentSize.height -
-                        scrollView.bounds.size.height +
-                        inset.bottom + kRJScrollEpsilon;
+                        scrollView.bounds.size.height + inset.bottom +
+                        kRJScrollEpsilon;
 
   if (offset.y < topLimit || offset.y > bottomLimit) {
     return YES;
@@ -669,8 +697,8 @@ typedef struct {
 
   CGFloat leftLimit = -inset.left - kRJScrollEpsilon;
   CGFloat rightLimit = scrollView.contentSize.width -
-                       scrollView.bounds.size.width +
-                       inset.right + kRJScrollEpsilon;
+                       scrollView.bounds.size.width + inset.right +
+                       kRJScrollEpsilon;
   if (offset.x < leftLimit || offset.x > rightLimit) {
     return YES;
   }
@@ -690,8 +718,8 @@ typedef struct {
     return YES;
   }
 
-  CGFloat triggerOffset = -scrollView.adjustedContentInset.top -
-                          kRJScrollEpsilon;
+  CGFloat triggerOffset =
+      -scrollView.adjustedContentInset.top - kRJScrollEpsilon;
   if (offset.y < triggerOffset) {
     return YES;
   }
@@ -709,9 +737,9 @@ typedef struct {
 }
 
 - (void)updateScrollActiveState:(BOOL)scrollActive
-                    refreshActive:(BOOL)refreshActive
-                         mapActive:(BOOL)mapActive
-                               now:(NSTimeInterval)now {
+                  refreshActive:(BOOL)refreshActive
+                      mapActive:(BOOL)mapActive
+                            now:(NSTimeInterval)now {
   if (self.scrollActive && !scrollActive) {
     [self scheduleBonusCaptureAfterDelay:kRJBonusScrollDelaySeconds now:now];
   }
@@ -734,7 +762,7 @@ typedef struct {
 #pragma mark - Map Tracking
 
 - (void)updateTrackedMapViews:(NSArray<NSValue *> *)mapViewPointers
-                           now:(NSTimeInterval)now {
+                          now:(NSTimeInterval)now {
   if (!mapViewPointers) {
     return;
   }
@@ -763,9 +791,9 @@ typedef struct {
     self.lastMapTime = now;
   }
   [self updateScrollActiveState:self.scrollActive
-                    refreshActive:self.refreshActive
-                         mapActive:anyMapActive || self.mapActive
-                               now:now];
+                  refreshActive:self.refreshActive
+                      mapActive:anyMapActive || self.mapActive
+                            now:now];
 }
 
 - (BOOL)updateMapStateForView:(UIView *)view atTime:(NSTimeInterval)now {
@@ -836,8 +864,7 @@ typedef struct {
 
 - (void)probeAnimatedViewsAtTime:(NSTimeInterval)now {
   if (self.churnBlocking) {
-    if ((now - self.lastSignatureChurnTime) <
-        kRJSignatureChurnWindowSeconds) {
+    if ((now - self.lastSignatureChurnTime) < kRJSignatureChurnWindowSeconds) {
       self.lastAnimationTime = now;
       return;
     }
@@ -863,15 +890,14 @@ typedef struct {
     self.lastAnimationTime = now;
   } else {
     self.animationBlocking = NO;
-    [self scheduleBonusCaptureAfterDelay:kRJBonusAnimationDelaySeconds
-                                     now:now];
+    [self scheduleBonusCaptureAfterDelay:kRJBonusAnimationDelaySeconds now:now];
   }
 }
 
 #pragma mark - Bonus Capture
 
 - (void)scheduleBonusCaptureAfterDelay:(NSTimeInterval)delay
-                                    now:(NSTimeInterval)now {
+                                   now:(NSTimeInterval)now {
   if (self.pendingKeyframes < kRJMaxPendingKeyframes) {
     self.pendingKeyframes += 1;
   }
@@ -886,9 +912,9 @@ typedef struct {
 - (void)considerBlockerSince:(NSTimeInterval)timestamp
                quietInterval:(NSTimeInterval)quietInterval
                          now:(NSTimeInterval)now
-                     reason:(RJCaptureHeuristicsReason)reason
-               earliestTime:(NSTimeInterval *)earliestTime
-               chosenReason:(RJCaptureHeuristicsReason *)chosenReason {
+                      reason:(RJCaptureHeuristicsReason)reason
+                earliestTime:(NSTimeInterval *)earliestTime
+                chosenReason:(RJCaptureHeuristicsReason *)chosenReason {
   if (timestamp <= 0) {
     return;
   }

package/ios/Core/Rejourney.mm

@@ -943,33 +943,54 @@ RCT_EXPORT_METHOD(setDebugMode : (BOOL)enabled resolve : (
 
 RCT_EXPORT_METHOD(setUserIdentity : (NSString *)userId resolve : (
     RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
-  dispatch_async(dispatch_get_main_queue(), ^{
+  dispatch_async(self.stateQueue, ^{
     @try {
       NSString *safeUserId = userId.length > 0 ? userId : @"anonymous";
 
-      [self performStateSync:^{
-        self.userId = safeUserId;
-      }];
+      // KEY CHANGE: Persist directly to NSUserDefaults (Native Storage)
+      [[NSUserDefaults standardUserDefaults] setObject:safeUserId
+                                                forKey:@"rj_user_identity"];
+      [[NSUserDefaults standardUserDefaults] synchronize];
 
+      self.userId = safeUserId;
       if (self.uploadManager) {
         self.uploadManager.userId = safeUserId;
       }
 
-      RJLogDebug(@"User identity updated: %@", safeUserId);
+      RJLogDebug(@"User identity updated and persisted: %@", safeUserId);
 
       if (self.isRecording) {
-        [self logEventInternal:@"user_identity_changed"
-                       details:@{@"userId" : safeUserId}];
+        // 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];
+        }
+        if (self.sessionEvents && !self.isShuttingDown) {
+          [self.sessionEvents addObject:event];
+        }
       }
 
-      resolve(@{@"success" : @YES});
+      if (resolve)
+        resolve(@{@"success" : @YES});
     } @catch (NSException *exception) {
-      RJLogWarning(@"setUserIdentity failed: %@", exception);
-      resolve(@{@"success" : @NO});
+      if (resolve)
+        resolve(@{@"success" : @NO});
     }
   });
 }
 
+RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  NSString *userId =
+      [[NSUserDefaults standardUserDefaults] stringForKey:@"rj_user_identity"];
+  resolve(userId ?: [NSNull null]);
+}
+
 #pragma mark - RJTouchInterceptorDelegate
 
 - (void)touchInterceptorDidDetectInteractionStart {
@@ -2345,6 +2366,10 @@ RCT_EXPORT_METHOD(setUserIdentity : (NSString *)userId resolve : (
       self.uploadManager.totalBackgroundTimeMs = 0;
 
       // Preserve user identity
+      if (!self.userId) {
+        self.userId = [[NSUserDefaults standardUserDefaults]
+            stringForKey:@"rj_user_identity"];
+      }
       self.uploadManager.userId = self.userId ?: @"anonymous";
     }
 

package/lib/commonjs/index.js

@@ -276,7 +276,6 @@ function getAutoTracking() {
 }
 
 // State
-const USER_IDENTITY_KEY = '@rejourney_user_identity';
 let _isInitialized = false;
 let _isRecording = false;
 let _initializationFailed = false;
@@ -291,22 +290,17 @@ let _lastScrollOffset = 0;
 const SCROLL_THROTTLE_MS = 100;
 
 // Helper to save/load user identity
-async function persistUserIdentity(identity) {
-  try {
-    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
-    if (identity) {
-      await AsyncStorage.setItem(USER_IDENTITY_KEY, identity);
-    } else {
-      await AsyncStorage.removeItem(USER_IDENTITY_KEY);
-    }
-  } catch (e) {
-    // Ignore storage errors
-  }
+// NOW HANDLED NATIVELY - No-op on JS side to avoid unnecessary bridge calls
+async function persistUserIdentity(_identity) {
+  // Native module handles persistence automatically in setUserIdentity
 }
 async function loadPersistedUserIdentity() {
   try {
-    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
-    return await AsyncStorage.getItem(USER_IDENTITY_KEY);
+    const nativeModule = getRejourneyNative();
+    if (!nativeModule) return null;
+
+    // NATIVE STORAGE: Read directly from SharedPreferences/NSUserDefaults
+    return await nativeModule.getUserIdentity();
   } catch (e) {
     return null;
   }