@rejourneyco/react-native 1.0.1 → 1.0.2

package/lib/commonjs/sdk/autoTracking.js

@@ -61,9 +61,6 @@ function getPlatform() {
 function getDimensions() {
   return getRN()?.Dimensions;
 }
-function getNativeModules() {
-  return getRN()?.NativeModules;
-}
 function getRejourneyNativeModule() {
   const RN = getRN();
   if (!RN) return null;
@@ -76,7 +73,7 @@ function getRejourneyNativeModule() {
     try {
       nativeModule = TurboModuleRegistry.get('Rejourney');
     } catch {
-      // Ignore and fall back to NativeModules
+      // Ignore
     }
   }
   if (!nativeModule && NativeModules) {
@@ -84,57 +81,27 @@ 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
-
-// Cast globalThis to work with both RN and hybrid scenarios
 const _globalThis = globalThis;
-
-// =============================================================================
-// Types
-// =============================================================================
-
-// =============================================================================
-// State
-// =============================================================================
-
 let isInitialized = false;
 let config = {};
-
-// Rage tap tracking
 const recentTaps = [];
-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 = createEmptyMetrics();
 let sessionStartTime = 0;
 let maxSessionDurationMs = 10 * 60 * 1000;
-
-// Screen tracking
 let currentScreen = '';
 let screensVisited = [];
-
-// Anonymous ID
 let anonymousId = null;
 let anonymousIdPromise = null;
-
-// Callbacks
 let onRageTapDetected = null;
 let onErrorCaptured = null;
 let onScreenChange = null;
-
-// Original error handlers (for restoration)
 let originalErrorHandler;
 let originalOnError = null;
 let originalOnUnhandledRejection = null;
 
-// =============================================================================
-// Initialization
-// =============================================================================
-
 /**
  * Initialize auto tracking features
  * Called automatically by Rejourney.init() - no user action needed
@@ -152,23 +119,13 @@ function initAutoTracking(trackingConfig, callbacks = {}) {
     maxSessionDurationMs: trackingConfig.maxSessionDurationMs,
     ...trackingConfig
   };
-
-  // Session timing
   sessionStartTime = Date.now();
   setMaxSessionDurationMinutes(trackingConfig.maxSessionDurationMs ? trackingConfig.maxSessionDurationMs / 60000 : 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;
   });
@@ -180,11 +137,7 @@ function initAutoTracking(trackingConfig, callbacks = {}) {
  */
 function cleanupAutoTracking() {
   if (!isInitialized) return;
-
-  // Restore original error handlers
   restoreErrorHandlers();
-
-  // Cleanup navigation tracking
   cleanupNavigationTracking();
 
   // Reset state
@@ -198,10 +151,6 @@ function cleanupAutoTracking() {
   isInitialized = false;
 }
 
-// =============================================================================
-// Rage Tap Detection
-// =============================================================================
-
 /**
  * Track a tap event for rage tap detection
  * Called automatically from touch interceptor
@@ -209,8 +158,6 @@ function cleanupAutoTracking() {
 function trackTap(tap) {
   if (!isInitialized) return;
   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] = {
@@ -219,15 +166,12 @@ function trackTap(tap) {
     };
     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];
@@ -238,11 +182,7 @@ function trackTap(tap) {
       break;
     }
   }
-
-  // Check for rage tap
   detectRageTap();
-
-  // Update metrics
   metrics.touchCount++;
   metrics.totalEvents++;
 }
@@ -254,14 +194,11 @@ function detectRageTap() {
   const threshold = config.rageTapThreshold || 3;
   const radius = config.rageTapRadius || 50;
   if (tapCount < threshold) return;
-  // Check last N taps from circular buffer
   const tapsToCheck = [];
   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) {
@@ -270,8 +207,6 @@ function detectRageTap() {
   }
   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;
@@ -283,9 +218,7 @@ function detectRageTap() {
     }
   }
   if (allWithinRadius) {
-    // Rage tap detected!
     metrics.rageTapCount++;
-    // Clear circular buffer to prevent duplicate detection
     tapHead = 0;
     tapCount = 0;
 
@@ -296,10 +229,6 @@ function detectRageTap() {
   }
 }
 
-// =============================================================================
-// State Change Notification
-// =============================================================================
-
 /**
  * Notify that a state change occurred (navigation, modal, etc.)
  * Kept for API compatibility
@@ -308,25 +237,16 @@ function notifyStateChange() {
   // No-op - kept for backward compatibility
 }
 
-// =============================================================================
-// Error Tracking
-// =============================================================================
-
 /**
  * Setup automatic error tracking
  */
 function setupErrorTracking() {
-  // 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();
   }
@@ -337,16 +257,10 @@ function setupErrorTracking() {
  */
 function setupReactNativeErrorHandler() {
   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, isFatal) => {
-      // Track the error
       trackError({
         type: 'error',
         timestamp: Date.now(),
@@ -354,14 +268,12 @@ function setupReactNativeErrorHandler() {
         stack: error.stack,
         name: error.name || 'Error'
       });
-
-      // Call original handler
       if (originalErrorHandler) {
         originalErrorHandler(error, isFatal);
       }
     });
   } catch {
-    // ErrorUtils not available
+    // Ignore
   }
 }
 
@@ -370,8 +282,6 @@ function setupReactNativeErrorHandler() {
  */
 function setupJSErrorHandler() {
   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 = (message, source, lineno, colno, error) => {
       trackError({
@@ -381,8 +291,6 @@ function setupJSErrorHandler() {
         stack: error?.stack || `${source}:${lineno}:${colno}`,
         name: error?.name || 'Error'
       });
-
-      // Call original handler
       if (originalOnError) {
         return originalOnError(message, source, lineno, colno, error);
       }
@@ -415,7 +323,6 @@ function setupPromiseRejectionHandler() {
  * Restore original error handlers
  */
 function restoreErrorHandlers() {
-  // Restore React Native handler
   if (originalErrorHandler) {
     try {
       const ErrorUtils = _globalThis.ErrorUtils;
@@ -427,14 +334,10 @@ function restoreErrorHandlers() {
     }
     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;
@@ -464,16 +367,10 @@ function captureError(message, stack, name) {
     name: name || 'Error'
   });
 }
-
-// =============================================================================
-// Screen/Funnel Tracking - Automatic Navigation Detection
-// =============================================================================
-
-// Navigation detection state
 let navigationPollingInterval = 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
 
 /**
@@ -497,8 +394,6 @@ function trackNavigationState(state) {
     const {
       normalizeScreenName
     } = require('./navigation');
-
-    // Find the active screen recursively
     const findActiveScreen = navState => {
       if (!navState?.routes) return null;
       const index = navState.index ?? navState.routes.length - 1;
@@ -513,7 +408,7 @@ function trackNavigationState(state) {
       trackScreen(screenName);
     }
   } catch {
-    // Navigation tracking error
+    // Ignore
   }
 }
 
@@ -543,16 +438,11 @@ function trackNavigationState(state) {
  * ```
  */
 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?.();
@@ -567,11 +457,9 @@ function useNavigationTracking() {
         }
       }
     } catch {
-      // Navigation not ready yet
+      // Ignore
     }
   }, []);
-
-  // Return props to spread on NavigationContainer
   return {
     ref: navigationRef.current,
     onReady,
@@ -607,8 +495,7 @@ function setupNavigationTracking() {
         _utils.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__) {
         _utils.logger.debug('Expo Router not ready, retrying in', delay, 'ms');
       }
@@ -620,8 +507,6 @@ function setupNavigationTracking() {
       }
     }
   };
-
-  // Start first attempt after 200ms
   setTimeout(trySetup, 200);
 }
 
@@ -647,14 +532,10 @@ function trySetupExpoRouter() {
       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()';
@@ -662,34 +543,25 @@ function trySetupExpoRouter() {
           state = router.rootState;
           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');
@@ -698,11 +570,11 @@ function trySetupExpoRouter() {
               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) {
@@ -713,21 +585,15 @@ function trySetupExpoRouter() {
             trackScreen(screenName);
           }
         } else {
-          // Track consecutive failures to get state
           navigationPollingErrors++;
           if (__DEV__ && navigationPollingErrors === 1) {
             _utils.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__) {
-              _utils.logger.debug('Expo Router: Stopped polling after', MAX_POLLING_ERRORS, 'errors');
-            }
             cleanupNavigationTracking();
           }
         }
       } catch (e) {
-        // Error - track and potentially stop
         navigationPollingErrors++;
         if (__DEV__ && navigationPollingErrors === 1) {
           _utils.logger.debug('Expo Router polling error:', e);
@@ -736,14 +602,12 @@ function trySetupExpoRouter() {
           cleanupNavigationTracking();
         }
       }
-    }, 500); // 500ms polling (reduced from 300ms for lower CPU usage)
-
+    }, 500);
     return true;
   } catch (e) {
     if (__DEV__) {
       _utils.logger.debug('Expo Router not available:', e);
     }
-    // expo-router not installed
     return false;
   }
 }
@@ -758,22 +622,12 @@ function extractScreenNameFromRouterState(state, getScreenNameFromPath, normaliz
   if (!state?.routes) return null;
   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, getScreenNameFromPath, normalizeScreenName, newSegments);
   }
-
-  // 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(')')) {
@@ -812,27 +666,17 @@ function trackScreen(screenName) {
   }
   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++;
   if (__DEV__) {
     _utils.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) {
@@ -854,18 +698,12 @@ function trackScreen(screenName) {
   }
 }
 
-// =============================================================================
-// API Metrics Tracking
-// =============================================================================
-
 /**
  * Track an API request with timing data
  */
 function trackAPIRequest(success, _statusCode, durationMs = 0, responseBytes = 0) {
   if (!isInitialized) return;
   metrics.apiTotalCount++;
-
-  // Accumulate timing and size for avg calculation
   if (durationMs > 0) {
     metrics.netTotalDurationMs += durationMs;
   }
@@ -876,16 +714,10 @@ function trackAPIRequest(success, _statusCode, durationMs = 0, responseBytes = 0
     metrics.apiSuccessCount++;
   } else {
     metrics.apiErrorCount++;
-
-    // API errors also count toward error count for UX score
     metrics.errorCount++;
   }
 }
 
-// =============================================================================
-// Session Metrics
-// =============================================================================
-
 /**
  * Create empty metrics object
  */
@@ -943,18 +775,11 @@ function trackInput() {
  * Get current session metrics
  */
 function getSessionMetrics() {
-  // 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
     netAvgDurationMs
   };
 }
@@ -963,34 +788,15 @@ function getSessionMetrics() {
  * Calculate session scores
  */
 function calculateScores() {
-  // 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
-
-  // Deduct for rage taps
-  uxScore -= Math.min(24, metrics.rageTapCount * 8); // Max 24 point deduction
-
-  // Deduct for API errors
-  uxScore -= Math.min(20, metrics.apiErrorCount * 10); // Max 20 point deduction
-
-  // Bonus for completing funnel (if screens > 3)
+  uxScore -= Math.min(30, metrics.errorCount * 15);
+  uxScore -= Math.min(24, metrics.rageTapCount * 8);
+  uxScore -= Math.min(20, metrics.apiErrorCount * 10);
   if (metrics.uniqueScreensCount >= 3) {
     uxScore += 5;
   }
@@ -1008,43 +814,29 @@ function resetMetrics() {
   tapCount = 0;
   sessionStartTime = Date.now();
 }
-
-// =============================================================================
-// Session duration helpers
-// =============================================================================
-
-/** Clamp and set max session duration in minutes (1–10). Defaults to 10. */
 function setMaxSessionDurationMinutes(minutes) {
   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. */
 function hasExceededMaxSessionDuration() {
   if (!sessionStartTime) return false;
   return Date.now() - sessionStartTime >= maxSessionDurationMs;
 }
-
-/** Returns remaining milliseconds until the session should stop. */
 function getRemainingSessionDurationMs() {
   if (!sessionStartTime) return maxSessionDurationMs;
   const remaining = maxSessionDurationMs - (Date.now() - sessionStartTime);
   return Math.max(0, remaining);
 }
 
-// =============================================================================
-// Device Info Collection
-// =============================================================================
-
 /**
  * Collect device information
  */
-function collectDeviceInfo() {
+/**
+ * Collect device information
+ */
+async function collectDeviceInfo() {
   const Dimensions = getDimensions();
   const Platform = getPlatform();
-  const NativeModules = getNativeModules();
-
-  // Default values if react-native isn't available
   let width = 0,
     height = 0,
     scale = 1;
@@ -1056,100 +848,43 @@ function collectDeviceInfo() {
     scale = screenDims?.scale || 1;
   }
 
-  // Get device model - this varies by platform
-  let model = 'Unknown';
-  let manufacturer;
-  let osVersion = 'Unknown';
-  let appVersion;
-  let appId;
+  // Basic JS-side info
   let locale;
   let timezone;
   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 locale
-  if (!locale) {
+  // Get native info
+  const nativeModule = getRejourneyNativeModule();
+  let nativeInfo = {};
+  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',
-    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
  */
@@ -1177,7 +912,6 @@ async function ensurePersistentAnonymousId() {
   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;
@@ -1207,12 +941,7 @@ async function loadAnonymousId() {
  */
 function setAnonymousId(id) {
   anonymousId = id;
-  // No-op for async persistence as we moved to native-only or memory-only
 }
-
-// =============================================================================
-// Exports
-// =============================================================================
 var _default = exports.default = {
   init: initAutoTracking,
   cleanup: cleanupAutoTracking,