@rejourneyco/react-native 1.0.9 → 1.0.10

package/lib/module/index.js

@@ -160,7 +160,12 @@ const noopAutoTracking = {
   getSessionMetrics: () => ({}),
   resetMetrics: () => {},
   collectDeviceInfo: async () => ({}),
-  ensurePersistentAnonymousId: async () => 'anonymous'
+  ensurePersistentAnonymousId: async () => 'anonymous',
+  useNavigationTracking: () => ({
+    ref: null,
+    onReady: () => {},
+    onStateChange: () => {}
+  })
 };
 function getAutoTracking() {
   if (_sdkDisabled) return noopAutoTracking;
@@ -183,6 +188,11 @@ let _appStateSubscription = null;
 let _authErrorSubscription = null;
 let _currentAppState = 'active'; // Default to active, will be updated on init
 let _userIdentity = null;
+let _backgroundEntryTime = null; // Track when app went to background
+let _storedMetadata = {}; // Accumulate metadata for session rollover
+
+// Session timeout - must match native side (60 seconds)
+const SESSION_TIMEOUT_MS = 60_000;
 
 // Scroll throttling - reduce native bridge calls from 60fps to at most 10/sec
 let _lastScrollTime = 0;
@@ -437,7 +447,7 @@ function safeNativeCallSync(methodName, fn, defaultValue) {
 /**
  * Main Rejourney API (Internal)
  */
-const Rejourney = {
+export const Rejourney = {
   /**
    * SDK Version
    */
@@ -573,7 +583,8 @@ const Rejourney = {
         trackPromiseRejections: true,
         trackReactNativeErrors: true,
         trackConsoleLogs: _storedConfig?.trackConsoleLogs ?? true,
-        collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false
+        collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false,
+        autoTrackExpoRouter: _storedConfig?.autoTrackExpoRouter !== false
       }, {
         // Rage tap callback - log as frustration event
         onRageTap: (count, x, y) => {
@@ -606,7 +617,7 @@ const Rejourney = {
           // RejourneyNetworkInterceptor on Android) are supplementary — they capture
           // native-originated HTTP calls that bypass JS fetch(), but cannot intercept
           // RN's own networking since it creates its NSURLSession/OkHttpClient at init time.
-          const ignoreUrls = [apiUrl, '/api/sdk/config', '/api/ingest/presign', '/api/ingest/batch/complete', '/api/ingest/session/end', ...(_storedConfig?.networkIgnoreUrls || [])];
+          const ignoreUrls = [apiUrl, '/api/sdk/config', '/api/ingest/presign', '/api/ingest/batch/complete', '/api/ingest/session/end', '/api/ingest/segment/presign', '/api/ingest/segment/complete', ...(_storedConfig?.networkIgnoreUrls || [])];
           getNetworkInterceptor().initNetworkInterceptor(request => {
             getAutoTracking().trackAPIRequest(request.success || false, request.statusCode, request.duration || 0, request.responseBodySize || 0);
             Rejourney.logNetworkRequest(request);
@@ -695,17 +706,57 @@ const Rejourney = {
     }
   },
   /**
-   * Tag the current screen
+  /**
+   * Set custom session metadata.
+   * Can be called with a single key-value pair or an object of properties.
+   * Useful for filtering sessions later (e.g., plan: 'premium', role: 'admin').
+   * Caps at 100 properties per session.
+   * 
+   * @param keyOrProperties Property name string, or an object containing key-value pairs
+   * @param value Property value (if first argument is a string)
+   */
+  setMetadata(keyOrProperties, value) {
+    if (typeof keyOrProperties === 'string') {
+      const key = keyOrProperties;
+      if (!key) {
+        getLogger().warn('setMetadata requires a non-empty string key');
+        return;
+      }
+      if (value !== undefined && typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+        getLogger().warn('setMetadata value must be a string, number, or boolean when using a key string');
+        return;
+      }
+      this.logEvent('$user_property', {
+        key,
+        value
+      });
+      // Track for session rollover restoration
+      _storedMetadata[key] = value;
+    } else if (keyOrProperties && typeof keyOrProperties === 'object') {
+      const properties = keyOrProperties;
+      const validProps = {};
+      for (const [k, v] of Object.entries(properties)) {
+        if (typeof k === 'string' && k && (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')) {
+          validProps[k] = v;
+        }
+      }
+      if (Object.keys(validProps).length > 0) {
+        this.logEvent('$user_property', validProps);
+        // Track for session rollover restoration
+        Object.assign(_storedMetadata, validProps);
+      }
+    } else {
+      getLogger().warn('setMetadata requires a string key and value, or a properties object');
+    }
+  },
+  /**
+   * Track current screen (manual)
    * 
    * @param screenName - Screen name
    * @param params - Optional screen parameters
    */
-  tagScreen(screenName, _params) {
+  trackScreen(screenName, _params) {
     getAutoTracking().trackScreen(screenName);
-    getAutoTracking().notifyStateChange();
-    safeNativeCallSync('tagScreen', () => {
-      getRejourneyNative().screenChanged(screenName).catch(() => {});
-    }, undefined);
   },
   /**
    * Mark a view as sensitive (will be occluded in recordings)
@@ -1094,13 +1145,109 @@ const Rejourney = {
     safeNativeCallSync('unmaskView', () => {
       getRejourneyNative().unmaskViewByNativeID(nativeID).catch(() => {});
     }, undefined);
+  },
+  /**
+   * Initialize Rejourney SDK
+   */
+  init(publicRouteKey, options) {
+    initRejourney(publicRouteKey, options);
+  },
+  /**
+   * Start recording
+   */
+  start() {
+    startRejourney();
+  },
+  /**
+   * Stop recording
+   */
+  stop() {
+    stopRejourney();
+  },
+  /**
+   * Hook for automatic React Navigation tracking.
+   */
+  useNavigationTracking() {
+    return getAutoTracking().useNavigationTracking();
   }
 };
 
+/**
+ * Reinitialize JS-side auto-tracking for a new session after background timeout.
+ *
+ * When the app was in background for >60s the native layer rolls over to a
+ * fresh session automatically.  The JS side must tear down stale tracking
+ * state (metrics, console-log counter, screen history, error handlers) and
+ * re-initialize so that trackScreen, logEvent, setMetadata, etc. work
+ * correctly against the new native session.
+ */
+function _reinitAutoTrackingForNewSession() {
+  try {
+    // 1. Tear down old session's auto-tracking state
+    getAutoTracking().cleanupAutoTracking();
+
+    // 2. Re-initialize auto-tracking with the same config
+    getAutoTracking().initAutoTracking({
+      rageTapThreshold: _storedConfig?.rageTapThreshold ?? 3,
+      rageTapTimeWindow: _storedConfig?.rageTapTimeWindow ?? 500,
+      rageTapRadius: 50,
+      trackJSErrors: true,
+      trackPromiseRejections: true,
+      trackReactNativeErrors: true,
+      trackConsoleLogs: _storedConfig?.trackConsoleLogs ?? true,
+      collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false,
+      autoTrackExpoRouter: _storedConfig?.autoTrackExpoRouter !== false
+    }, {
+      onRageTap: (count, x, y) => {
+        Rejourney.logEvent('frustration', {
+          frustrationKind: 'rage_tap',
+          tapCount: count,
+          x,
+          y
+        });
+        getLogger().logFrustration(`Rage tap (${count} taps)`);
+      },
+      onError: error => {
+        getLogger().logError(error.message);
+      },
+      onScreen: (_screenName, _previousScreen) => {}
+    });
+
+    // 3. Re-collect device info for the new session
+    if (_storedConfig?.collectDeviceInfo !== false) {
+      getAutoTracking().collectDeviceInfo().then(deviceInfo => {
+        Rejourney.logEvent('device_info', deviceInfo);
+      }).catch(() => {});
+    }
+
+    // 4. Re-send user identity to the new native session
+    if (_userIdentity) {
+      safeNativeCallSync('setUserIdentity', () => {
+        getRejourneyNative().setUserIdentity(_userIdentity).catch(() => {});
+      }, undefined);
+      getLogger().debug(`Restored user identity '${_userIdentity}' to new session`);
+    }
+
+    // 5. Re-send any stored metadata to the new native session
+    if (Object.keys(_storedMetadata).length > 0) {
+      for (const [key, value] of Object.entries(_storedMetadata)) {
+        if (value !== undefined && value !== null) {
+          Rejourney.setMetadata(key, value);
+        }
+      }
+      getLogger().debug('Restored metadata to new session');
+    }
+    getLogger().logLifecycleEvent('JS auto-tracking reinitialized for new session');
+  } catch (error) {
+    getLogger().warn('Failed to reinitialize auto-tracking after session rollover:', error);
+  }
+}
+
 /**
  * Handle app state changes for automatic session management
  * - Pauses recording when app goes to background
  * - Resumes recording when app comes back to foreground
+ * - Reinitializes JS-side auto-tracking when native rolls over to a new session
  * - Cleans up properly when app is terminated
  */
 function handleAppStateChange(nextAppState) {
@@ -1109,9 +1256,22 @@ function handleAppStateChange(nextAppState) {
     if (_currentAppState.match(/active/) && nextAppState === 'background') {
       // App going to background - native module handles this automatically
       getLogger().logLifecycleEvent('App moving to background');
+      _backgroundEntryTime = Date.now();
     } else if (_currentAppState.match(/inactive|background/) && nextAppState === 'active') {
       // App coming back to foreground
       getLogger().logLifecycleEvent('App returning to foreground');
+
+      // Check if we exceeded the session timeout (60s).
+      // Native side will have already ended the old session and started a new
+      // one — we need to reset JS-side auto-tracking state to match.
+      if (_backgroundEntryTime && _isRecording) {
+        const backgroundDurationMs = Date.now() - _backgroundEntryTime;
+        if (backgroundDurationMs > SESSION_TIMEOUT_MS) {
+          getLogger().debug(`Session rollover: background ${Math.round(backgroundDurationMs / 1000)}s > ${SESSION_TIMEOUT_MS / 1000}s timeout`);
+          _reinitAutoTrackingForNewSession();
+        }
+      }
+      _backgroundEntryTime = null;
     }
     _currentAppState = nextAppState;
   } catch (error) {
@@ -1176,8 +1336,10 @@ function setupAuthErrorListener() {
         }
       });
     }
-  } catch (error) {
-    getLogger().debug('Auth error listener not available:', error);
+  } catch {
+    // Expected on some architectures where NativeEventEmitter isn't fully supported.
+    // Auth errors are still handled synchronously via native callback — this listener
+    // is purely supplementary. No need to log.
   }
 }
 
@@ -1314,7 +1476,7 @@ export function stopRejourney() {
 }
 export default Rejourney;
 export * from './types';
-export { trackTap, trackScroll, trackGesture, trackInput, trackScreen, captureError, getSessionMetrics } from './sdk/autoTracking';
+export { trackTap, trackScroll, trackGesture, trackInput, captureError, getSessionMetrics } from './sdk/autoTracking';
 export { trackNavigationState, useNavigationTracking } from './sdk/autoTracking';
 export { LogLevel } from './sdk/utils';
 

package/lib/module/sdk/autoTracking.js

@@ -119,6 +119,7 @@ export function initAutoTracking(trackingConfig, callbacks = {}) {
     trackReactNativeErrors: true,
     trackConsoleLogs: true,
     collectDeviceInfo: true,
+    autoTrackExpoRouter: true,
     maxSessionDurationMs: trackingConfig.maxSessionDurationMs,
     ...trackingConfig
   };
@@ -568,10 +569,26 @@ function restoreConsoleHandlers() {
   // Note: console.error is restored in restoreErrorHandlers via originalConsoleError
 }
 let navigationPollingInterval = null;
+/** Interval ID from optional expo-router entry; cleared in cleanupNavigationTracking */
+let expoRouterPollingIntervalId = null;
 let lastDetectedScreen = '';
 let navigationSetupDone = false;
-let navigationPollingErrors = 0;
-const MAX_POLLING_ERRORS = 10; // Stop polling after 10 consecutive errors
+
+/**
+ * Register the polling interval from the optional expo-router entry so we can clear it on cleanup.
+ * Used by src/expoRouterTracking.ts (only loaded when app imports '@rejourneyco/react-native/expo-router').
+ */
+export function setExpoRouterPollingInterval(id) {
+  expoRouterPollingIntervalId = id;
+}
+
+/**
+ * Check if Expo Router auto-tracking is enabled in the current configuration.
+ * Used by src/expoRouterTracking.ts.
+ */
+export function isExpoRouterTrackingEnabled() {
+  return config.autoTrackExpoRouter !== false;
+}
 
 /**
  * Track a navigation state change from React Navigation.
@@ -668,91 +685,94 @@ export function useNavigationTracking() {
 }
 
 /**
- * Setup automatic Expo Router tracking
- * 
- * For Expo apps using expo-router - works automatically.
- * For bare React Native apps - use trackNavigationState instead.
+ * Setup automatic navigation tracking.
+ *
+ * Expo Router: not set up here to avoid pulling expo-router into the main bundle
+ * (Metro resolves require() at build time, which causes "Requiring unknown module"
+ * in apps that use Expo + react-navigation without expo-router). If you use
+ * expo-router, add: import '@rejourneyco/react-native/expo-router';
+ *
+ * For React Navigation (non–expo-router), use trackNavigationState() on your
+ * NavigationContainer's onStateChange.
  */
 function setupNavigationTracking() {
   if (navigationSetupDone) return;
   navigationSetupDone = true;
-  if (__DEV__) {
-    logger.debug('Setting up navigation tracking...');
+
+  // Auto-detect expo-router and set up screen tracking if available.
+  // This is safe: if expo-router isn't installed, the require fails silently.
+  // We defer slightly so the router has time to initialize after JS bundle load.
+  if (config.autoTrackExpoRouter !== false) {
+    tryAutoSetupExpoRouter();
   }
-  let attempts = 0;
-  const maxAttempts = 5;
-  const trySetup = () => {
-    attempts++;
-    if (__DEV__) {
-      logger.debug('Navigation setup attempt', attempts, 'of', maxAttempts);
-    }
-    const success = trySetupExpoRouter();
-    if (success) {
-      if (__DEV__) {
-        logger.debug('Expo Router setup: SUCCESS on attempt', attempts);
-      }
-    } else if (attempts < maxAttempts) {
-      const delay = 200 * attempts;
-      if (__DEV__) {
-        logger.debug('Expo Router not ready, retrying in', delay, 'ms');
+}
+
+/**
+ * Attempt to auto-detect and set up expo-router screen tracking.
+ * Uses a retry mechanism because the router may not be ready immediately
+ * after JS bundle load.
+ */
+function tryAutoSetupExpoRouter(attempt = 0, maxAttempts = 5) {
+  const delay = 200 * (attempt + 1); // 200, 400, 600, 800, 1000ms
+
+  setTimeout(() => {
+    try {
+      // Dynamic require wrapped in a variable to prevent Metro from statically resolving it
+      const EXPO_ROUTER = 'expo-router';
+      const expoRouter = require(EXPO_ROUTER);
+      if (!expoRouter?.router) {
+        // expo-router exists but router not ready yet — retry
+        if (attempt < maxAttempts - 1) {
+          tryAutoSetupExpoRouter(attempt + 1, maxAttempts);
+        }
+        return;
       }
-      setTimeout(trySetup, delay);
-    } else {
-      if (__DEV__) {
-        logger.debug('Expo Router setup: FAILED after', maxAttempts, 'attempts');
-        logger.debug('For manual navigation tracking, use trackNavigationState() on your NavigationContainer');
+
+      // Router is ready — set up the polling-based screen tracker
+      setupExpoRouterPolling(expoRouter.router);
+    } catch {
+      // expo-router not installed — this is fine, just means the app
+      // uses bare React Navigation or no navigation at all.
+      if (__DEV__ && attempt === 0) {
+        logger.debug('Expo Router not detected, skipping auto screen tracking. Use trackNavigationState() for React Navigation.');
       }
     }
-  };
-  setTimeout(trySetup, 200);
+  }, delay);
 }
 
 /**
-   * Set up Expo Router auto-tracking by polling the internal router store
-   * 
-   * Supports both expo-router v3 (store.rootState) and v6+ (store.state, store.navigationRef)
-   */
-function trySetupExpoRouter() {
+ * Poll expo-router state for screen changes.
+ * Inlined from expoRouterTracking.ts so no separate import is needed.
+ */
+function setupExpoRouterPolling(router) {
+  // Guard against double-setup (core auto-detection + legacy expoRouterTracking.ts import)
+  if (expoRouterPollingIntervalId != null) return;
+  const MAX_POLLING_ERRORS = 10;
+  let pollingErrors = 0;
   try {
-    const expoRouter = require('expo-router');
-    const router = expoRouter.router;
-    if (!router) {
-      if (__DEV__) {
-        logger.debug('Expo Router: router object not found');
-      }
-      return false;
-    }
-    if (__DEV__) {
-      logger.debug('Expo Router: Setting up navigation tracking');
-    }
     const {
       normalizeScreenName,
       getScreenNameFromPath
     } = require('./navigation');
-    navigationPollingInterval = setInterval(() => {
+    const intervalId = setInterval(() => {
       try {
         let state = null;
-        let stateSource = '';
         if (typeof router.getState === 'function') {
           state = router.getState();
-          stateSource = 'router.getState()';
         } else if (router.rootState) {
           state = router.rootState;
-          stateSource = 'router.rootState';
         }
         if (!state) {
           try {
-            const storeModule = require('expo-router/build/global-state/router-store');
+            const STORE_PATH = 'expo-router/build/global-state/router-store';
+            const storeModule = require(STORE_PATH);
             if (storeModule?.store) {
               state = storeModule.store.state;
-              if (state) stateSource = 'store.state';
               if (!state && storeModule.store.navigationRef?.current) {
                 state = storeModule.store.navigationRef.current.getRootState?.();
-                if (state) stateSource = 'navigationRef.getRootState()';
               }
               if (!state) {
                 state = storeModule.store.rootState || storeModule.store.initialState;
-                if (state) stateSource = 'store.rootState/initialState';
               }
             }
           } catch {
@@ -761,67 +781,53 @@ function trySetupExpoRouter() {
         }
         if (!state) {
           try {
-            const imperative = require('expo-router/build/imperative-api');
+            const IMPERATIVE_PATH = 'expo-router/build/imperative-api';
+            const imperative = require(IMPERATIVE_PATH);
             if (imperative?.router) {
               state = imperative.router.getState?.();
-              if (state) stateSource = 'imperative-api';
             }
           } catch {
             // Ignore
           }
         }
         if (state) {
-          navigationPollingErrors = 0;
-          navigationPollingErrors = 0;
+          pollingErrors = 0;
           const screenName = extractScreenNameFromRouterState(state, getScreenNameFromPath, normalizeScreenName);
           if (screenName && screenName !== lastDetectedScreen) {
-            if (__DEV__) {
-              logger.debug('Screen changed:', lastDetectedScreen, '->', screenName, `(source: ${stateSource})`);
-            }
             lastDetectedScreen = screenName;
             trackScreen(screenName);
           }
         } else {
-          navigationPollingErrors++;
-          if (__DEV__ && navigationPollingErrors === 1) {
-            logger.debug('Expo Router: Could not get navigation state');
-          }
-          if (navigationPollingErrors >= MAX_POLLING_ERRORS) {
-            cleanupNavigationTracking();
+          pollingErrors++;
+          if (pollingErrors >= MAX_POLLING_ERRORS) {
+            clearInterval(intervalId);
+            expoRouterPollingIntervalId = null;
           }
         }
-      } catch (e) {
-        navigationPollingErrors++;
-        if (__DEV__ && navigationPollingErrors === 1) {
-          logger.debug('Expo Router polling error:', e);
-        }
-        if (navigationPollingErrors >= MAX_POLLING_ERRORS) {
-          cleanupNavigationTracking();
+      } catch {
+        pollingErrors++;
+        if (pollingErrors >= MAX_POLLING_ERRORS) {
+          clearInterval(intervalId);
+          expoRouterPollingIntervalId = null;
         }
       }
     }, 500);
-    return true;
-  } catch (e) {
-    if (__DEV__) {
-      logger.debug('Expo Router not available:', e);
-    }
-    return false;
+    expoRouterPollingIntervalId = intervalId;
+  } catch {
+    // navigation module not available — ignore
   }
 }
 
 /**
- * Extract screen name from Expo Router navigation state
- * 
- * Handles complex nested structures like Drawer → Tabs → Stack
- * by recursively accumulating segments from each navigation level.
+ * Extract the active screen name from expo-router navigation state.
  */
-function extractScreenNameFromRouterState(state, getScreenNameFromPath, normalizeScreenName, accumulatedSegments = []) {
+function extractScreenNameFromRouterState(state, getScreenNameFromPathFn, normalizeScreenNameFn, accumulatedSegments = []) {
   if (!state?.routes) return null;
   const route = state.routes[state.index ?? state.routes.length - 1];
   if (!route) return null;
   const newSegments = [...accumulatedSegments, route.name];
   if (route.state) {
-    return extractScreenNameFromRouterState(route.state, getScreenNameFromPath, normalizeScreenName, newSegments);
+    return extractScreenNameFromRouterState(route.state, getScreenNameFromPathFn, normalizeScreenNameFn, newSegments);
   }
   const cleanSegments = newSegments.filter(s => !s.startsWith('(') && !s.endsWith(')'));
   if (cleanSegments.length === 0) {
@@ -834,7 +840,7 @@ function extractScreenNameFromRouterState(state, getScreenNameFromPath, normaliz
     }
   }
   const pathname = '/' + cleanSegments.join('/');
-  return getScreenNameFromPath(pathname, newSegments);
+  return getScreenNameFromPathFn(pathname, newSegments);
 }
 
 /**
@@ -845,9 +851,12 @@ function cleanupNavigationTracking() {
     clearInterval(navigationPollingInterval);
     navigationPollingInterval = null;
   }
+  if (expoRouterPollingIntervalId != null) {
+    clearInterval(expoRouterPollingIntervalId);
+    expoRouterPollingIntervalId = null;
+  }
   navigationSetupDone = false;
   lastDetectedScreen = '';
-  navigationPollingErrors = 0;
 }
 
 /**

package/lib/typescript/expoRouterTracking.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Optional Expo Router integration for @rejourneyco/react-native
+ *
+ * This file is only loaded when you import '@rejourneyco/react-native/expo-router'.
+ * It contains require('expo-router') and related subpaths. Metro bundles require()
+ * at build time, so keeping this in a separate entry ensures apps that use
+ * Expo with react-navigation (without expo-router) never pull in expo-router
+ * and avoid "Requiring unknown module" crashes.
+ *
+ * If you use expo-router, add this once (e.g. in your root _layout.tsx):
+ *   import '@rejourneyco/react-native/expo-router';
+ */
+export {};
+//# sourceMappingURL=expoRouterTracking.d.ts.map

package/lib/typescript/index.d.ts

@@ -26,7 +26,7 @@ import type { RejourneyConfig, RejourneyAPI } from './types';
 /**
  * Main Rejourney API (Internal)
  */
-declare const Rejourney: RejourneyAPI;
+export declare const Rejourney: RejourneyAPI;
 /**
  * Initialize Rejourney SDK - STEP 1 of 3
  *
@@ -81,7 +81,7 @@ export declare function startRejourney(): void;
 export declare function stopRejourney(): void;
 export default Rejourney;
 export * from './types';
-export { trackTap, trackScroll, trackGesture, trackInput, trackScreen, captureError, getSessionMetrics, } from './sdk/autoTracking';
+export { trackTap, trackScroll, trackGesture, trackInput, captureError, getSessionMetrics, } from './sdk/autoTracking';
 export { trackNavigationState, useNavigationTracking } from './sdk/autoTracking';
 export { LogLevel } from './sdk/utils';
 /**

package/lib/typescript/sdk/autoTracking.d.ts

@@ -68,6 +68,7 @@ export interface AutoTrackingConfig {
     collectDeviceInfo?: boolean;
     maxSessionDurationMs?: number;
     detectDeadTaps?: boolean;
+    autoTrackExpoRouter?: boolean;
 }
 /**
  * Mark a tap as handled.
@@ -101,6 +102,16 @@ export declare function notifyStateChange(): void;
  * Manually track an error (for API errors, etc.)
  */
 export declare function captureError(message: string, stack?: string, name?: string): void;
+/**
+ * Register the polling interval from the optional expo-router entry so we can clear it on cleanup.
+ * Used by src/expoRouterTracking.ts (only loaded when app imports '@rejourneyco/react-native/expo-router').
+ */
+export declare function setExpoRouterPollingInterval(id: ReturnType<typeof setInterval> | null): void;
+/**
+ * Check if Expo Router auto-tracking is enabled in the current configuration.
+ * Used by src/expoRouterTracking.ts.
+ */
+export declare function isExpoRouterTrackingEnabled(): boolean;
 /**
  * Track a navigation state change from React Navigation.
  *