@rejourneyco/react-native 1.0.1 → 1.0.3

package/src/sdk/autoTracking.ts

@@ -42,9 +42,7 @@ function getDimensions() {
   return getRN()?.Dimensions;
 }
 
-function getNativeModules() {
-  return getRN()?.NativeModules;
-}
+
 
 function getRejourneyNativeModule() {
   const RN = getRN();
@@ -57,7 +55,7 @@ function getRejourneyNativeModule() {
     try {
       nativeModule = TurboModuleRegistry.get('Rejourney');
     } catch {
-      // Ignore and fall back to NativeModules
+      // Ignore
     }
   }
 
@@ -68,8 +66,6 @@ function getRejourneyNativeModule() {
   return nativeModule;
 }
 
-// Type declarations for browser globals (only used in hybrid apps where DOM is available)
-// These don't exist in pure React Native but are needed for error tracking in hybrid scenarios
 type OnErrorEventHandler = ((
   event: Event | string,
   source?: string,
@@ -83,7 +79,6 @@ interface PromiseRejectionEvent {
   promise?: Promise<any>;
 }
 
-// Cast globalThis to work with both RN and hybrid scenarios
 const _globalThis = globalThis as typeof globalThis & {
   onerror?: OnErrorEventHandler;
   addEventListener?: (type: string, handler: (event: any) => void) => void;
@@ -94,10 +89,6 @@ const _globalThis = globalThis as typeof globalThis & {
   };
 };
 
-// =============================================================================
-// Types
-// =============================================================================
-
 export interface TapEvent {
   x: number;
   y: number;
@@ -106,93 +97,63 @@ export interface TapEvent {
 }
 
 export interface SessionMetrics {
-  // Core counts
   totalEvents: number;
   touchCount: number;
   scrollCount: number;
   gestureCount: number;
   inputCount: number;
   navigationCount: number;
-
-  // Issue tracking
   errorCount: number;
   rageTapCount: number;
-
-  // API metrics
   apiSuccessCount: number;
   apiErrorCount: number;
   apiTotalCount: number;
-
-  // Network timing (for avg calculation)
-  netTotalDurationMs: number;  // Sum of all API durations
-  netTotalBytes: number;       // Sum of all response bytes
-
-  // Screen tracking for funnels
+  netTotalDurationMs: number;
+  netTotalBytes: number;
   screensVisited: string[];
   uniqueScreensCount: number;
 
-  // Scores (0-100)
   interactionScore: number;
   explorationScore: number;
   uxScore: number;
 }
 
 export interface AutoTrackingConfig {
-  // Rage tap detection
-  rageTapThreshold?: number;    // Number of taps (default: 3)
-  rageTapTimeWindow?: number;   // Time window in ms (default: 500)
-  rageTapRadius?: number;       // Max radius in pixels (default: 50)
-
-  // Error tracking
-  trackJSErrors?: boolean;      // Track window errors (default: true)
-  trackPromiseRejections?: boolean; // Track unhandled rejections (default: true)
-  trackReactNativeErrors?: boolean; // Track RN ErrorUtils (default: true)
-
-  // Session settings
-  collectDeviceInfo?: boolean;  // Collect device info (default: true)
-  maxSessionDurationMs?: number; // Clamp to 1–10 minutes; default set from server/config
+  rageTapThreshold?: number;
+  rageTapTimeWindow?: number;
+  rageTapRadius?: number;
+  trackJSErrors?: boolean;
+  trackPromiseRejections?: boolean;
+  trackReactNativeErrors?: boolean;
+  collectDeviceInfo?: boolean;
+  maxSessionDurationMs?: number;
 }
 
-// =============================================================================
-// State
-// =============================================================================
-
 let isInitialized = false;
 let config: AutoTrackingConfig = {};
 
-// Rage tap tracking
 const recentTaps: TapEvent[] = [];
-let tapHead = 0; // Circular buffer head pointer
-let tapCount = 0; // Actual count of taps in buffer
+let tapHead = 0;
+let tapCount = 0;
 const MAX_RECENT_TAPS = 10;
 
-// Session metrics
 let metrics: SessionMetrics = createEmptyMetrics();
 let sessionStartTime: number = 0;
 let maxSessionDurationMs: number = 10 * 60 * 1000;
-
-// Screen tracking
 let currentScreen = '';
 let screensVisited: string[] = [];
 
-// Anonymous ID
 let anonymousId: string | null = null;
 let anonymousIdPromise: Promise<string> | null = null;
 
-// Callbacks
 let onRageTapDetected: ((count: number, x: number, y: number) => void) | null = null;
 let onErrorCaptured: ((error: ErrorEvent) => void) | null = null;
 let onScreenChange: ((screenName: string, previousScreen?: string) => void) | null = null;
 
-// Original error handlers (for restoration)
 let originalErrorHandler: ((error: Error, isFatal: boolean) => void) | undefined;
 let originalOnError: OnErrorEventHandler | null = null;
 let originalOnUnhandledRejection: ((event: PromiseRejectionEvent) => void) | null = null;
 
-// =============================================================================
-// Initialization
-// =============================================================================
-
 /**
  * Initialize auto tracking features
  * Called automatically by Rejourney.init() - no user action needed
@@ -219,7 +180,6 @@ export function initAutoTracking(
     ...trackingConfig,
   };
 
-  // Session timing
   sessionStartTime = Date.now();
   setMaxSessionDurationMinutes(
     trackingConfig.maxSessionDurationMs
@@ -227,18 +187,11 @@ export function initAutoTracking(
       : undefined
   );
 
-  // Set callbacks
   onRageTapDetected = callbacks.onRageTap || null;
   onErrorCaptured = callbacks.onError || null;
   onScreenChange = callbacks.onScreen || null;
-
-  // Setup error tracking
   setupErrorTracking();
-
-  // Setup React Navigation tracking (if available)
   setupNavigationTracking();
-
-  // Load anonymous ID from native storage (or generate new one)
   loadAnonymousId().then(id => {
     anonymousId = id;
   });
@@ -252,10 +205,7 @@ export function initAutoTracking(
 export function cleanupAutoTracking(): void {
   if (!isInitialized) return;
 
-  // Restore original error handlers
   restoreErrorHandlers();
-
-  // Cleanup navigation tracking
   cleanupNavigationTracking();
 
   // Reset state
@@ -269,10 +219,6 @@ export function cleanupAutoTracking(): void {
   isInitialized = false;
 }
 
-// =============================================================================
-// Rage Tap Detection
-// =============================================================================
-
 /**
  * Track a tap event for rage tap detection
  * Called automatically from touch interceptor
@@ -282,18 +228,14 @@ export function trackTap(tap: TapEvent): void {
 
   const now = Date.now();
 
-  // Add to circular buffer (O(1) instead of shift() which is O(n))
   const insertIndex = (tapHead + tapCount) % MAX_RECENT_TAPS;
   if (tapCount < MAX_RECENT_TAPS) {
     recentTaps[insertIndex] = { ...tap, timestamp: now };
     tapCount++;
   } else {
-    // Buffer full, overwrite oldest
     recentTaps[tapHead] = { ...tap, timestamp: now };
     tapHead = (tapHead + 1) % MAX_RECENT_TAPS;
   }
-
-  // Evict old taps outside time window
   const windowStart = now - (config.rageTapTimeWindow || 500);
   while (tapCount > 0) {
     const oldestTap = recentTaps[tapHead];
@@ -305,10 +247,7 @@ export function trackTap(tap: TapEvent): void {
     }
   }
 
-  // Check for rage tap
   detectRageTap();
-
-  // Update metrics
   metrics.touchCount++;
   metrics.totalEvents++;
 }
@@ -321,14 +260,12 @@ function detectRageTap(): void {
   const radius = config.rageTapRadius || 50;
 
   if (tapCount < threshold) return;
-  // Check last N taps from circular buffer
   const tapsToCheck: TapEvent[] = [];
   for (let i = 0; i < threshold; i++) {
     const idx = (tapHead + tapCount - threshold + i) % MAX_RECENT_TAPS;
     tapsToCheck.push(recentTaps[idx]!);
   }
 
-  // Calculate center point
   let centerX = 0;
   let centerY = 0;
   for (const tap of tapsToCheck) {
@@ -338,7 +275,6 @@ function detectRageTap(): void {
   centerX /= tapsToCheck.length;
   centerY /= tapsToCheck.length;
 
-  // Check if all taps are within radius of center
   let allWithinRadius = true;
   for (const tap of tapsToCheck) {
     const dx = tap.x - centerX;
@@ -351,9 +287,7 @@ function detectRageTap(): void {
   }
 
   if (allWithinRadius) {
-    // Rage tap detected!
     metrics.rageTapCount++;
-    // Clear circular buffer to prevent duplicate detection
     tapHead = 0;
     tapCount = 0;
 
@@ -364,10 +298,6 @@ function detectRageTap(): void {
   }
 }
 
-// =============================================================================
-// State Change Notification
-// =============================================================================
-
 /**
  * Notify that a state change occurred (navigation, modal, etc.)
  * Kept for API compatibility
@@ -376,25 +306,18 @@ export function notifyStateChange(): void {
   // No-op - kept for backward compatibility
 }
 
-// =============================================================================
-// Error Tracking
-// =============================================================================
-
 /**
  * Setup automatic error tracking
  */
 function setupErrorTracking(): void {
-  // Track React Native errors
   if (config.trackReactNativeErrors !== false) {
     setupReactNativeErrorHandler();
   }
 
-  // Track JavaScript errors (only works in web/debug)
   if (config.trackJSErrors !== false && typeof _globalThis !== 'undefined') {
     setupJSErrorHandler();
   }
 
-  // Track unhandled promise rejections
   if (config.trackPromiseRejections !== false && typeof _globalThis !== 'undefined') {
     setupPromiseRejectionHandler();
   }
@@ -405,16 +328,12 @@ function setupErrorTracking(): void {
  */
 function setupReactNativeErrorHandler(): void {
   try {
-    // Access ErrorUtils from global scope
     const ErrorUtils = _globalThis.ErrorUtils;
     if (!ErrorUtils) return;
 
-    // Store original handler
     originalErrorHandler = ErrorUtils.getGlobalHandler();
 
-    // Set new handler
     ErrorUtils.setGlobalHandler((error: Error, isFatal: boolean) => {
-      // Track the error
       trackError({
         type: 'error',
         timestamp: Date.now(),
@@ -423,13 +342,12 @@ function setupReactNativeErrorHandler(): void {
         name: error.name || 'Error',
       });
 
-      // Call original handler
       if (originalErrorHandler) {
         originalErrorHandler(error, isFatal);
       }
     });
   } catch {
-    // ErrorUtils not available
+    // Ignore
   }
 }
 
@@ -438,8 +356,6 @@ function setupReactNativeErrorHandler(): void {
  */
 function setupJSErrorHandler(): void {
   if (typeof _globalThis.onerror !== 'undefined') {
-    // Note: In React Native, this typically doesn't fire
-    // But we set it up anyway for hybrid apps
     originalOnError = _globalThis.onerror;
 
     _globalThis.onerror = (
@@ -457,7 +373,6 @@ function setupJSErrorHandler(): void {
         name: error?.name || 'Error',
       });
 
-      // Call original handler
       if (originalOnError) {
         return originalOnError(message, source, lineno, colno, error);
       }
@@ -491,7 +406,6 @@ function setupPromiseRejectionHandler(): void {
  * Restore original error handlers
  */
 function restoreErrorHandlers(): void {
-  // Restore React Native handler
   if (originalErrorHandler) {
     try {
       const ErrorUtils = _globalThis.ErrorUtils;
@@ -504,13 +418,11 @@ function restoreErrorHandlers(): void {
     originalErrorHandler = undefined;
   }
 
-  // Restore global onerror
   if (originalOnError !== null) {
     _globalThis.onerror = originalOnError;
     originalOnError = null;
   }
 
-  // Remove promise rejection handler
   if (originalOnUnhandledRejection && typeof _globalThis.removeEventListener !== 'undefined') {
     _globalThis.removeEventListener!('unhandledrejection', originalOnUnhandledRejection);
     originalOnUnhandledRejection = null;
@@ -546,15 +458,10 @@ export function captureError(
   });
 }
 
-// =============================================================================
-// Screen/Funnel Tracking - Automatic Navigation Detection
-// =============================================================================
-
-// Navigation detection state
 let navigationPollingInterval: ReturnType<typeof setInterval> | null = null;
 let lastDetectedScreen = '';
 let navigationSetupDone = false;
-let navigationPollingErrors = 0; // Track consecutive errors
+let navigationPollingErrors = 0;
 const MAX_POLLING_ERRORS = 10; // Stop polling after 10 consecutive errors
 
 /**
@@ -578,7 +485,6 @@ export function trackNavigationState(state: any): void {
   try {
     const { normalizeScreenName } = require('./navigation');
 
-    // Find the active screen recursively
     const findActiveScreen = (navState: any): string | null => {
       if (!navState?.routes) return null;
       const index = navState.index ?? navState.routes.length - 1;
@@ -594,7 +500,7 @@ export function trackNavigationState(state: any): void {
       trackScreen(screenName);
     }
   } catch {
-    // Navigation tracking error
+    // Ignore
   }
 }
 
@@ -624,14 +530,11 @@ export function trackNavigationState(state: any): void {
  * ```
  */
 export function useNavigationTracking() {
-  // Use React's useRef and useCallback to create stable references
   const React = require('react');
   const { createNavigationContainerRef } = require('@react-navigation/native');
 
-  // Create a stable navigation ref
   const navigationRef = React.useRef(createNavigationContainerRef());
 
-  // Track initial screen when navigation is ready
   const onReady = React.useCallback(() => {
     try {
       const currentRoute = navigationRef.current?.getCurrentRoute?.();
@@ -644,11 +547,10 @@ export function useNavigationTracking() {
         }
       }
     } catch {
-      // Navigation not ready yet
+      // Ignore
     }
   }, []);
 
-  // Return props to spread on NavigationContainer
   return {
     ref: navigationRef.current,
     onReady,
@@ -670,8 +572,6 @@ function setupNavigationTracking(): void {
     logger.debug('Setting up navigation tracking...');
   }
 
-  // Delay to ensure navigation is initialized - Expo Router needs more time
-  // We retry a few times with increasing delays
   let attempts = 0;
   const maxAttempts = 5;
 
@@ -688,8 +588,7 @@ function setupNavigationTracking(): void {
         logger.debug('Expo Router setup: SUCCESS on attempt', attempts);
       }
     } else if (attempts < maxAttempts) {
-      // Retry with exponential backoff
-      const delay = 200 * attempts; // 200, 400, 600, 800ms
+      const delay = 200 * attempts;
       if (__DEV__) {
         logger.debug('Expo Router not ready, retrying in', delay, 'ms');
       }
@@ -702,7 +601,6 @@ function setupNavigationTracking(): void {
     }
   };
 
-  // Start first attempt after 200ms
   setTimeout(trySetup, 200);
 }
 
@@ -729,13 +627,10 @@ function trySetupExpoRouter(): boolean {
 
     const { normalizeScreenName, getScreenNameFromPath } = require('./navigation');
 
-    // Poll for route changes (expo-router doesn't expose a listener API outside hooks)
     navigationPollingInterval = setInterval(() => {
       try {
         let state = null;
         let stateSource = '';
-
-        // Method 1: Public accessors on router object
         if (typeof router.getState === 'function') {
           state = router.getState();
           stateSource = 'router.getState()';
@@ -744,33 +639,28 @@ function trySetupExpoRouter(): boolean {
           stateSource = 'router.rootState';
         }
 
-        // Method 2: Internal store access (works for both v3 and v6+)
         if (!state) {
           try {
             const storeModule = require('expo-router/build/global-state/router-store');
             if (storeModule?.store) {
-              // v6+: store.state or store.navigationRef
               state = storeModule.store.state;
               if (state) stateSource = 'store.state';
 
-              // v6+: Try navigationRef if state is undefined
               if (!state && storeModule.store.navigationRef?.current) {
                 state = storeModule.store.navigationRef.current.getRootState?.();
                 if (state) stateSource = 'navigationRef.getRootState()';
               }
 
-              // v3: store.rootState or store.initialState
               if (!state) {
                 state = storeModule.store.rootState || storeModule.store.initialState;
                 if (state) stateSource = 'store.rootState/initialState';
               }
             }
           } catch {
-            // Store not available
+            // Ignore
           }
         }
 
-        // Method 3: Try accessing via a different export path for v6
         if (!state) {
           try {
             const imperative = require('expo-router/build/imperative-api');
@@ -779,12 +669,12 @@ function trySetupExpoRouter(): boolean {
               if (state) stateSource = 'imperative-api';
             }
           } catch {
-            // Imperative API not available
+            // Ignore
           }
         }
 
         if (state) {
-          // Reset error count on success
+          navigationPollingErrors = 0;
           navigationPollingErrors = 0;
           const screenName = extractScreenNameFromRouterState(state, getScreenNameFromPath, normalizeScreenName);
           if (screenName && screenName !== lastDetectedScreen) {
@@ -795,21 +685,15 @@ function trySetupExpoRouter(): boolean {
             trackScreen(screenName);
           }
         } else {
-          // Track consecutive failures to get state
           navigationPollingErrors++;
           if (__DEV__ && navigationPollingErrors === 1) {
             logger.debug('Expo Router: Could not get navigation state');
           }
           if (navigationPollingErrors >= MAX_POLLING_ERRORS) {
-            // Stop polling after too many errors to save CPU
-            if (__DEV__) {
-              logger.debug('Expo Router: Stopped polling after', MAX_POLLING_ERRORS, 'errors');
-            }
             cleanupNavigationTracking();
           }
         }
       } catch (e) {
-        // Error - track and potentially stop
         navigationPollingErrors++;
         if (__DEV__ && navigationPollingErrors === 1) {
           logger.debug('Expo Router polling error:', e);
@@ -818,14 +702,13 @@ function trySetupExpoRouter(): boolean {
           cleanupNavigationTracking();
         }
       }
-    }, 500); // 500ms polling (reduced from 300ms for lower CPU usage)
+    }, 500);
 
     return true;
   } catch (e) {
     if (__DEV__) {
       logger.debug('Expo Router not available:', e);
     }
-    // expo-router not installed
     return false;
   }
 }
@@ -847,10 +730,8 @@ function extractScreenNameFromRouterState(
   const route = state.routes[state.index ?? state.routes.length - 1];
   if (!route) return null;
 
-  // Add current route name to accumulated segments
   const newSegments = [...accumulatedSegments, route.name];
 
-  // If this route has nested state, recurse deeper
   if (route.state) {
     return extractScreenNameFromRouterState(
       route.state,
@@ -860,13 +741,9 @@ function extractScreenNameFromRouterState(
     );
   }
 
-  // We've reached the deepest level - build the screen name
-  // Filter out group markers like (tabs), (main), (auth)
   const cleanSegments = newSegments.filter(s => !s.startsWith('(') && !s.endsWith(')'));
 
-  // If after filtering we have no segments, use the last meaningful name
   if (cleanSegments.length === 0) {
-    // Find the last non-group segment
     for (let i = newSegments.length - 1; i >= 0; i--) {
       const seg = newSegments[i];
       if (seg && !seg.startsWith('(') && !seg.endsWith(')')) {
@@ -907,14 +784,10 @@ export function trackScreen(screenName: string): void {
 
   const previousScreen = currentScreen;
   currentScreen = screenName;
-  // Add to screens visited (only track for unique set, avoid large array copies)
   screensVisited.push(screenName);
 
-  // Update unique screens count
   const uniqueScreens = new Set(screensVisited);
   metrics.uniqueScreensCount = uniqueScreens.size;
-
-  // Update navigation count
   metrics.navigationCount++;
   metrics.totalEvents++;
 
@@ -922,13 +795,10 @@ export function trackScreen(screenName: string): void {
     logger.debug('trackScreen:', screenName, '(total screens:', metrics.uniqueScreensCount, ')');
   }
 
-  // Notify callback
   if (onScreenChange) {
     onScreenChange(screenName, previousScreen);
   }
 
-  // IMPORTANT: Also notify native module to send to backend
-  // This is the key fix - without this, screens don't get recorded!
   try {
     const RejourneyNative = getRejourneyNativeModule();
     if (RejourneyNative?.screenChanged) {
@@ -950,10 +820,6 @@ export function trackScreen(screenName: string): void {
   }
 }
 
-// =============================================================================
-// API Metrics Tracking
-// =============================================================================
-
 /**
  * Track an API request with timing data
  */
@@ -967,7 +833,6 @@ export function trackAPIRequest(
 
   metrics.apiTotalCount++;
 
-  // Accumulate timing and size for avg calculation
   if (durationMs > 0) {
     metrics.netTotalDurationMs += durationMs;
   }
@@ -979,16 +844,10 @@ export function trackAPIRequest(
     metrics.apiSuccessCount++;
   } else {
     metrics.apiErrorCount++;
-
-    // API errors also count toward error count for UX score
     metrics.errorCount++;
   }
 }
 
-// =============================================================================
-// Session Metrics
-// =============================================================================
-
 /**
  * Create empty metrics object
  */
@@ -1046,19 +905,15 @@ export function trackInput(): void {
  * Get current session metrics
  */
 export function getSessionMetrics(): SessionMetrics & { netAvgDurationMs: number } {
-  // Calculate scores before returning
   calculateScores();
 
-  // Compute average API response time
   const netAvgDurationMs = metrics.apiTotalCount > 0
     ? Math.round(metrics.netTotalDurationMs / metrics.apiTotalCount)
     : 0;
 
-  // Lazily populate screensVisited only when metrics are retrieved
-  // This avoids expensive array copies on every screen change
   return {
     ...metrics,
-    screensVisited: [...screensVisited], // Only copy here when needed
+    screensVisited: [...screensVisited],
     netAvgDurationMs,
   };
 }
@@ -1067,38 +922,26 @@ export function getSessionMetrics(): SessionMetrics & { netAvgDurationMs: number
  * Calculate session scores
  */
 function calculateScores(): void {
-  // Interaction Score (0-100)
-  // Based on total interactions normalized to a baseline
   const totalInteractions =
     metrics.touchCount +
     metrics.scrollCount +
     metrics.gestureCount +
     metrics.inputCount;
 
-  // Assume 50 interactions is "average" for a session
   const avgInteractions = 50;
   metrics.interactionScore = Math.min(100, Math.round((totalInteractions / avgInteractions) * 100));
 
-  // Exploration Score (0-100)
-  // Based on unique screens visited
-  // Assume 5 screens is "average" exploration
   const avgScreens = 5;
   metrics.explorationScore = Math.min(100, Math.round((metrics.uniqueScreensCount / avgScreens) * 100));
 
-  // UX Score (0-100)
-  // Starts at 100, deducts for issues
   let uxScore = 100;
 
-  // Deduct for errors
-  uxScore -= Math.min(30, metrics.errorCount * 15); // Max 30 point deduction
+  uxScore -= Math.min(30, metrics.errorCount * 15);
 
-  // Deduct for rage taps
-  uxScore -= Math.min(24, metrics.rageTapCount * 8); // Max 24 point deduction
+  uxScore -= Math.min(24, metrics.rageTapCount * 8);
 
-  // Deduct for API errors
-  uxScore -= Math.min(20, metrics.apiErrorCount * 10); // Max 20 point deduction
+  uxScore -= Math.min(20, metrics.apiErrorCount * 10);
 
-  // Bonus for completing funnel (if screens > 3)
   if (metrics.uniqueScreensCount >= 3) {
     uxScore += 5;
   }
@@ -1118,42 +961,31 @@ export function resetMetrics(): void {
   sessionStartTime = Date.now();
 }
 
-// =============================================================================
-// Session duration helpers
-// =============================================================================
-
-/** Clamp and set max session duration in minutes (1–10). Defaults to 10. */
 export function setMaxSessionDurationMinutes(minutes?: number): void {
   const clampedMinutes = Math.min(10, Math.max(1, minutes ?? 10));
   maxSessionDurationMs = clampedMinutes * 60 * 1000;
 }
-
-/** Returns true if the current session exceeded the configured max duration. */
 export function hasExceededMaxSessionDuration(): boolean {
   if (!sessionStartTime) return false;
   return Date.now() - sessionStartTime >= maxSessionDurationMs;
 }
 
-/** Returns remaining milliseconds until the session should stop. */
 export function getRemainingSessionDurationMs(): number {
   if (!sessionStartTime) return maxSessionDurationMs;
   const remaining = maxSessionDurationMs - (Date.now() - sessionStartTime);
   return Math.max(0, remaining);
 }
 
-// =============================================================================
-// Device Info Collection
-// =============================================================================
-
 /**
  * Collect device information
  */
-export function collectDeviceInfo(): DeviceInfo {
+/**
+ * Collect device information
+ */
+export async function collectDeviceInfo(): Promise<DeviceInfo> {
   const Dimensions = getDimensions();
   const Platform = getPlatform();
-  const NativeModules = getNativeModules();
 
-  // Default values if react-native isn't available
   let width = 0, height = 0, scale = 1;
 
   if (Dimensions) {
@@ -1164,105 +996,46 @@ export function collectDeviceInfo(): DeviceInfo {
     scale = screenDims?.scale || 1;
   }
 
-  // Get device model - this varies by platform
-  let model = 'Unknown';
-  let manufacturer: string | undefined;
-  let osVersion = 'Unknown';
-  let appVersion: string | undefined;
-  let appId: string | undefined;
+  // Basic JS-side info
   let locale: string | undefined;
   let timezone: string | undefined;
 
   try {
-    // Try to get from react-native-device-info if available
-    // This is optional - falls back to basic info if not installed
-    const DeviceInfo = require('react-native-device-info');
-    model = DeviceInfo.getModel?.() || model;
-    manufacturer = DeviceInfo.getBrand?.() || undefined;
-    osVersion = DeviceInfo.getSystemVersion?.() || osVersion;
-    appVersion = DeviceInfo.getVersion?.() || undefined;
-    appId = DeviceInfo.getBundleId?.() || undefined;
-    locale = DeviceInfo.getDeviceLocale?.() || undefined;
-    timezone = DeviceInfo.getTimezone?.() || undefined;
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    locale = Intl.DateTimeFormat().resolvedOptions().locale;
   } catch {
-    // react-native-device-info not installed, try Expo packages
-    try {
-      // Try expo-application for app version/id
-      const Application = require('expo-application');
-      appVersion = Application.nativeApplicationVersion || Application.applicationVersion || undefined;
-      appId = Application.applicationId || undefined;
-    } catch {
-      // expo-application not available
-    }
-
-    try {
-      // Try expo-constants for additional info
-      const Constants = require('expo-constants');
-      const expoConfig = Constants.expoConfig || Constants.manifest2?.extra?.expoClient || Constants.manifest;
-      if (!appVersion && expoConfig?.version) {
-        appVersion = expoConfig.version;
-      }
-      if (!appId && (expoConfig?.ios?.bundleIdentifier || expoConfig?.android?.package)) {
-        appId = Platform?.OS === 'ios'
-          ? expoConfig?.ios?.bundleIdentifier
-          : expoConfig?.android?.package;
-      }
-    } catch {
-      // expo-constants not available
-    }
-
-    // Fall back to basic platform info
-    if (Platform?.OS === 'ios') {
-      // Get basic info from constants
-      const PlatformConstants = NativeModules?.PlatformConstants;
-      osVersion = Platform.Version?.toString() || osVersion;
-      model = PlatformConstants?.interfaceIdiom === 'pad' ? 'iPad' : 'iPhone';
-    } else if (Platform?.OS === 'android') {
-      osVersion = Platform.Version?.toString() || osVersion;
-      model = 'Android Device';
-    }
+    // Ignore
   }
 
-  // Get timezone
-  if (!timezone) {
-    try {
-      timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    } catch {
-      timezone = undefined;
-    }
-  }
+  // Get native info
+  const nativeModule = getRejourneyNativeModule();
+  let nativeInfo: any = {};
 
-  // Get locale
-  if (!locale) {
+  if (nativeModule && nativeModule.getDeviceInfo) {
     try {
-      locale = Intl.DateTimeFormat().resolvedOptions().locale;
-    } catch {
-      locale = undefined;
+      nativeInfo = await nativeModule.getDeviceInfo();
+    } catch (e) {
+      if (__DEV__) {
+        console.warn('[Rejourney] Failed to get native device info:', e);
+      }
     }
   }
 
   return {
-    model,
-    manufacturer,
+    model: nativeInfo.model || 'Unknown',
+    manufacturer: nativeInfo.brand,
     os: (Platform?.OS || 'ios') as 'ios' | 'android',
-    osVersion,
+    osVersion: nativeInfo.systemVersion || Platform?.Version?.toString() || 'Unknown',
     screenWidth: Math.round(width),
     screenHeight: Math.round(height),
     pixelRatio: scale,
-    appVersion,
-    appId,
-    locale,
-    timezone,
+    appVersion: nativeInfo.appVersion,
+    appId: nativeInfo.bundleId,
+    locale: locale,
+    timezone: timezone,
   };
 }
 
-// =============================================================================
-// Anonymous ID Generation
-// =============================================================================
-
-// Storage key for anonymous ID
-// const ANONYMOUS_ID_KEY = '@rejourney_anonymous_id';
-
 /**
  * Generate a persistent anonymous ID
  */
@@ -1290,7 +1063,6 @@ export async function ensurePersistentAnonymousId(): Promise<string> {
   if (anonymousId) return anonymousId;
   if (!anonymousIdPromise) {
     anonymousIdPromise = (async () => {
-      // Just use the load logic which now delegates to native or memory
       const id = await loadAnonymousId();
       anonymousId = id;
       return id;
@@ -1320,13 +1092,8 @@ export async function loadAnonymousId(): Promise<string> {
  */
 export function setAnonymousId(id: string): void {
   anonymousId = id;
-  // No-op for async persistence as we moved to native-only or memory-only
 }
 
-// =============================================================================
-// Exports
-// =============================================================================
-
 export default {
   init: initAutoTracking,
   cleanup: cleanupAutoTracking,