@athena-tracker/tracker 1.0.2 → 1.2.1

package/dist/index.js

@@ -2,186 +2,1385 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var React = require('react');
+var reactNative = require('react-native');
+
 /**
- * @athena-tracker/tracker
- * ATHENA Analytics tracker SDK wrapper
- */
-class AthenaTrackerSDK {
-    constructor(config) {
-        this.scriptLoaded = false;
-        this.loadPromise = null;
-        this.config = {
-            apiUrl: 'https://tracker.pascal.cx',
-            sampleRate: 1.0,
-            ...config,
-        };
+ * Auto-Detection Logic
+ *
+ * Automatically detects whether to use on-device or server-side inference
+ * based on availability of onnxruntime-react-native
+ */
+async function detectInferenceMode(configMode) {
+  // Respect explicit configuration
+  if (configMode === 'on-device') {
+    console.log('[ATHENA] Forcing on-device inference mode');
+    return 'on-device';
+  }
+  if (configMode === 'server') {
+    console.log('[ATHENA] Forcing server-side inference mode');
+    return 'server';
+  }
+  // Auto-detect based on onnxruntime-react-native availability
+  try {
+    // Try to dynamically import onnxruntime-react-native
+    await import('onnxruntime-react-native');
+    console.log('[ATHENA] On-device inference available (onnxruntime-react-native detected)');
+    return 'on-device';
+  } catch (error) {
+    console.log('[ATHENA] Falling back to server-side inference (onnxruntime-react-native not found)');
+    return 'server';
+  }
+}
+/**
+ * Check if running in React Native environment
+ */
+function isReactNative() {
+  return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+}
+/**
+ * Check if running in browser environment
+ */
+function isBrowser() {
+  return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+/**
+ * Get platform identifier
+ */
+function getPlatform() {
+  if (isReactNative()) {
+    return 'react-native';
+  } else if (isBrowser()) {
+    return 'web';
+  }
+  return 'unknown';
+}
+
+/**
+ * On-Device Inference Module
+ *
+ * Uses onnxruntime-react-native for local ML inference
+ * Target latency: <10ms P95
+ */
+let InferenceSession;
+let Tensor;
+// Dynamically import ONNX Runtime (only available in React Native)
+async function loadOnnxRuntime() {
+  try {
+    const onnx = await import('onnxruntime-react-native');
+    InferenceSession = onnx.InferenceSession;
+    Tensor = onnx.Tensor;
+    return true;
+  } catch (error) {
+    console.error('[ATHENA] Failed to load onnxruntime-react-native:', error);
+    return false;
+  }
+}
+class OnDeviceInference {
+  constructor() {
+    this.session = null;
+    this.modelLoaded = false;
+  }
+  /**
+   * Initialize ONNX session with model file
+   */
+  async initialize(modelPath) {
+    console.log('[ATHENA] Loading ONNX model for on-device inference...');
+    // Load ONNX Runtime
+    const loaded = await loadOnnxRuntime();
+    if (!loaded) {
+      throw new Error('onnxruntime-react-native not available');
     }
-    /**
-     * Load the ATHENA tracker script dynamically
-     */
-    async load() {
-        if (this.scriptLoaded)
-            return;
-        if (this.loadPromise)
-            return this.loadPromise;
-        this.loadPromise = new Promise((resolve, reject) => {
-            const script = document.createElement('script');
-            script.src = `${this.config.apiUrl}/v1/tracker.min.js`;
-            script.async = true;
-            script.onload = () => {
-                this.scriptLoaded = true;
-                this.initialize();
-                resolve();
-            };
-            script.onerror = () => {
-                reject(new Error('Failed to load ATHENA tracker script'));
-            };
-            document.head.appendChild(script);
-        });
-        return this.loadPromise;
-    }
-    /**
-     * Initialize the tracker with configuration
-     */
-    initialize() {
-        if (typeof window !== 'undefined' && window.PascalTracker) {
-            window.athenaTracker = new window.PascalTracker(this.config);
-        }
+    try {
+      const startTime = performance.now();
+      this.session = await InferenceSession.create(modelPath);
+      const loadTime = performance.now() - startTime;
+      this.modelLoaded = true;
+      console.log(`[ATHENA] ONNX model loaded successfully (${loadTime.toFixed(0)}ms)`);
+    } catch (error) {
+      console.error('[ATHENA] Failed to load ONNX model:', error);
+      throw new Error(`Model loading failed: ${error}`);
     }
-    /**
-     * Get the underlying tracker instance
-     */
-    getTracker() {
-        if (typeof window === 'undefined') {
-            console.warn('ATHENA Tracker: window is not defined (SSR environment)');
-            return null;
-        }
-        if (!window.athenaTracker) {
-            console.warn('ATHENA Tracker: not initialized. Call load() first.');
-            return null;
-        }
-        return window.athenaTracker;
-    }
-    /**
-     * Identify a user
-     */
-    identify(userId, properties) {
-        const tracker = this.getTracker();
-        if (tracker && tracker.identify) {
-            tracker.identify({
-                userId,
-                ...properties,
-            });
-        }
+  }
+  /**
+   * Run inference on feature vector
+   */
+  async predict(features) {
+    if (!this.modelLoaded || !this.session) {
+      throw new Error('ONNX model not initialized. Call initialize() first.');
     }
-    /**
-     * Track a custom event
-     */
-    track(eventName, properties) {
-        const tracker = this.getTracker();
-        if (tracker && tracker.track) {
-            tracker.track(eventName, properties);
-        }
+    const startTime = performance.now();
+    try {
+      // Create input tensor
+      const inputTensor = new Tensor('float32', features, [1, features.length]);
+      const feeds = {
+        input: inputTensor
+      };
+      // Run inference
+      const results = await this.session.run(feeds);
+      const inferenceTime = performance.now() - startTime;
+      // Parse output
+      const prediction = this.parseOutput(results.output);
+      console.log(`[ATHENA] On-device inference complete: ${inferenceTime.toFixed(2)}ms ` + `(class: ${prediction.predicted_class}, confidence: ${prediction.confidence.toFixed(2)})`);
+      return {
+        ...prediction,
+        inference_time_ms: Math.round(inferenceTime * 100) / 100,
+        inference_location: 'on-device',
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[ATHENA] On-device inference failed:', error);
+      throw new Error(`Inference failed: ${error}`);
     }
-    /**
-     * Track a page view
-     */
-    page(pageName, properties) {
-        const tracker = this.getTracker();
-        if (tracker && tracker.page) {
-            tracker.page(pageName, properties);
-        }
+  }
+  /**
+   * Parse ONNX output tensor to prediction result
+   */
+  parseOutput(outputTensor) {
+    const data = outputTensor.data;
+    // Extract predictions from model output
+    // Model outputs: [predicted_class_idx, confidence, purchase_intent, cart_abandon_risk, checkout_abandon_risk]
+    const predictedClassIdx = data[0];
+    const confidence = data[1];
+    const purchaseIntent = data[2];
+    const cartAbandonRisk = data[3] || 0;
+    const checkoutAbandonRisk = data[4] || 0;
+    // Map class index to label
+    const classLabels = ['engaged_explorer', 'high_intent_buyer', 'cart_abandoner', 'checkout_abandoner', 'bounce_risk'];
+    const predictedClass = classLabels[predictedClassIdx] || 'unknown';
+    // Determine archetype based on purchase intent
+    let archetype;
+    if (purchaseIntent >= 0.85) {
+      archetype = 'fast_mover';
+    } else if (purchaseIntent >= 0.60) {
+      archetype = 'on_track';
+    } else if (purchaseIntent >= 0.40) {
+      archetype = 'slow_adopter';
+    } else if (purchaseIntent >= 0.20) {
+      archetype = 'at_risk';
+    } else {
+      archetype = 'different_path';
     }
-    /**
-     * Reset user identity (logout)
-     */
-    reset() {
-        const tracker = this.getTracker();
-        if (tracker && tracker.reset) {
-            tracker.reset();
-        }
+    // Generate recommendations
+    const recommendation = this.generateRecommendation(predictedClass, purchaseIntent, cartAbandonRisk, checkoutAbandonRisk);
+    return {
+      predicted_class: predictedClass,
+      confidence,
+      archetype,
+      purchase_intent: purchaseIntent,
+      cart_abandonment_risk: cartAbandonRisk,
+      checkout_abandonment_risk: checkoutAbandonRisk,
+      ...recommendation
+    };
+  }
+  /**
+   * Generate action recommendations based on prediction
+   */
+  generateRecommendation(predictedClass, purchaseIntent, cartAbandonRisk, checkoutAbandonRisk) {
+    // High cart abandonment risk
+    if (cartAbandonRisk > 0.7) {
+      return {
+        recommended_action: 'Show cart abandonment discount (10-15% off)',
+        urgency: 'high',
+        trigger_reason: `High cart abandonment risk (${(cartAbandonRisk * 100).toFixed(0)}%)`
+      };
+    }
+    // High checkout abandonment risk
+    if (checkoutAbandonRisk > 0.7) {
+      return {
+        recommended_action: 'Simplify checkout flow or offer free shipping',
+        urgency: 'critical',
+        trigger_reason: `High checkout abandonment risk (${(checkoutAbandonRisk * 100).toFixed(0)}%)`
+      };
+    }
+    // High purchase intent
+    if (purchaseIntent > 0.8) {
+      return {
+        recommended_action: 'Show product recommendations or upsell',
+        urgency: 'medium',
+        trigger_reason: `High purchase intent (${(purchaseIntent * 100).toFixed(0)}%)`
+      };
+    }
+    // Low purchase intent
+    if (purchaseIntent < 0.3) {
+      return {
+        recommended_action: 'Show value proposition or testimonials',
+        urgency: 'low',
+        trigger_reason: `Low purchase intent (${(purchaseIntent * 100).toFixed(0)}%)`
+      };
     }
-    /**
-     * Get current session ID
-     */
-    getSessionId() {
-        const tracker = this.getTracker();
-        if (tracker && tracker.getSessionId) {
-            return tracker.getSessionId();
+    return {
+      recommended_action: 'Continue monitoring',
+      urgency: 'low'
+    };
+  }
+  /**
+   * Check if model is loaded
+   */
+  isReady() {
+    return this.modelLoaded;
+  }
+  /**
+   * Cleanup resources
+   */
+  async dispose() {
+    if (this.session) {
+      try {
+        // ONNX Runtime sessions should be disposed
+        await this.session.release?.();
+        console.log('[ATHENA] On-device inference session disposed');
+      } catch (error) {
+        console.warn('[ATHENA] Failed to dispose session:', error);
+      }
+      this.session = null;
+      this.modelLoaded = false;
+    }
+  }
+}
+
+/**
+ * Server-Side Inference Module
+ *
+ * Fallback inference via HTTP API when on-device inference is not available
+ * Target latency: <100ms P95
+ */
+class ServerInference {
+  constructor(apiUrl, appToken, timeout = 5000) {
+    this.apiUrl = apiUrl;
+    this.appToken = appToken;
+    this.timeout = timeout;
+  }
+  /**
+   * Make prediction request to server
+   */
+  async predict(events, sessionId, userId) {
+    const startTime = Date.now();
+    try {
+      const requestBody = {
+        app_token: this.appToken,
+        events,
+        session_id: sessionId,
+        user_id: userId
+      };
+      console.log(`[ATHENA] Sending ${events.length} events to server for inference...`);
+      const response = await this.fetchWithTimeout(this.apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-App-Token': this.appToken
+        },
+        body: JSON.stringify(requestBody)
+      }, this.timeout);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Server inference failed: ${response.status} ${errorText}`);
+      }
+      const result = await response.json();
+      const latency = Date.now() - startTime;
+      console.log(`[ATHENA] Server-side inference complete: ${latency}ms ` + `(class: ${result.predicted_class}, confidence: ${result.confidence.toFixed(2)})`);
+      return {
+        ...result,
+        inference_time_ms: latency,
+        inference_location: 'server',
+        timestamp: result.timestamp || new Date().toISOString()
+      };
+    } catch (error) {
+      const latency = Date.now() - startTime;
+      console.error(`[ATHENA] Server inference failed after ${latency}ms:`, error.message);
+      throw new Error(`Server inference failed: ${error.message}`);
+    }
+  }
+  /**
+   * Fetch with timeout
+   */
+  async fetchWithTimeout(url, options, timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === 'AbortError') {
+        throw new Error(`Request timeout after ${timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Test server connectivity
+   */
+  async testConnection() {
+    try {
+      // Replace /v1/predict with /health for health check
+      const healthUrl = this.apiUrl.replace('/v1/predict', '/health');
+      console.log(`[ATHENA] Testing server connectivity: ${healthUrl}`);
+      const response = await this.fetchWithTimeout(healthUrl, {
+        method: 'GET'
+      }, Math.min(this.timeout, 5000)); // Use 5s max for health check
+      if (response.ok) {
+        console.log('[ATHENA] Server connectivity test passed');
+      }
+      return response.ok;
+    } catch (error) {
+      console.warn('[ATHENA] Server connectivity test failed:', error.message || error);
+      console.warn('[ATHENA] URL attempted:', this.apiUrl.replace('/v1/predict', '/health'));
+      return false;
+    }
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(apiUrl, appToken, timeout) {
+    if (apiUrl) this.apiUrl = apiUrl;
+    if (appToken) this.appToken = appToken;
+    if (timeout) this.timeout = timeout;
+  }
+}
+
+/**
+ * ATHENA Tracker - Main Class
+ *
+ * Unified interface for behavioral tracking with dual-mode ML inference
+ */
+const DEFAULT_API_URL = 'https://tracker.pascal.cx';
+const DEFAULT_ML_API_URL = 'https://pascal-ml-api-344769701859.us-central1.run.app';
+const DEFAULT_MODEL_PATH = 'https://tracker.pascal.cx/models/base_model_int8.onnx';
+const DEFAULT_BATCH_SIZE = 10;
+const DEFAULT_BATCH_INTERVAL_MS = 10000; // 10 seconds
+class AthenaTracker {
+  constructor() {
+    this.config = null;
+    this.state = {
+      initialized: false,
+      inferenceMode: null,
+      sessionId: null,
+      userId: null,
+      events: []
+    };
+    this.onDeviceInference = null;
+    this.serverInference = null;
+    this.batchIntervalId = null;
+    this.failureCount = 0;
+    this.maxFailures = 3;
+    // External IDs for custom audience building (Meta, Google)
+    this.externalIds = {};
+    // Private constructor for singleton
+  }
+  /**
+   * Get singleton instance
+   */
+  static getInstance() {
+    if (!AthenaTracker.instance) {
+      AthenaTracker.instance = new AthenaTracker();
+    }
+    return AthenaTracker.instance;
+  }
+  /**
+   * Initialize tracker
+   */
+  static async init(config) {
+    const instance = AthenaTracker.getInstance();
+    if (instance.state.initialized) {
+      console.warn('[ATHENA] Already initialized');
+      return;
+    }
+    console.log('[ATHENA] Initializing tracker...');
+    instance.config = {
+      ...config,
+      apiUrl: config.apiUrl || DEFAULT_API_URL,
+      modelPath: config.modelPath || DEFAULT_MODEL_PATH,
+      serverInferenceUrl: config.serverInferenceUrl || `${DEFAULT_ML_API_URL}/v1/predict`,
+      batching: {
+        size: config.batching?.size || DEFAULT_BATCH_SIZE,
+        intervalMs: config.batching?.intervalMs || DEFAULT_BATCH_INTERVAL_MS
+      }
+    };
+    // Detect inference mode
+    const detectedMode = await detectInferenceMode(config.inferenceMode);
+    instance.state.inferenceMode = detectedMode;
+    // Initialize appropriate inference engine
+    if (detectedMode === 'on-device') {
+      await instance.initializeOnDevice();
+    } else {
+      await instance.initializeServer();
+    }
+    // Generate session ID
+    instance.state.sessionId = instance.generateSessionId();
+    // Generate anonymous user ID (will be replaced on identify())
+    instance.state.userId = instance.generateAnonymousId();
+    // Capture external IDs for custom audience building (browser only)
+    instance.captureExternalIds();
+    // Start event batching
+    instance.startBatching();
+    instance.state.initialized = true;
+    console.log(`[ATHENA] Tracker initialized successfully (mode: ${detectedMode}, platform: ${getPlatform()})`);
+  }
+  /**
+   * Initialize on-device inference
+   */
+  async initializeOnDevice() {
+    try {
+      this.onDeviceInference = new OnDeviceInference();
+      await this.onDeviceInference.initialize(this.config.modelPath);
+      console.log('[ATHENA] On-device inference ready');
+    } catch (error) {
+      console.error('[ATHENA] On-device inference initialization failed:', error);
+      console.log('[ATHENA] Falling back to server-side inference');
+      this.state.inferenceMode = 'server';
+      await this.initializeServer();
+    }
+  }
+  /**
+   * Initialize server-side inference
+   */
+  async initializeServer() {
+    this.serverInference = new ServerInference(this.config.serverInferenceUrl, this.config.appToken, this.config.timeout || 5000 // Use configured timeout or default to 5s
+    );
+    // Test connectivity
+    const connected = await this.serverInference.testConnection();
+    if (!connected) {
+      console.warn('[ATHENA] Server connectivity test failed - predictions may fail');
+    } else {
+      console.log('[ATHENA] Server-side inference ready');
+    }
+  }
+  /**
+   * Identify a user
+   * Supports email/phone hashing for Meta/Google custom audiences
+   *
+   * @param userId - User identifier
+   * @param traits - User traits (email, phone, name, etc.)
+   * @param options - Optional configuration
+   */
+  static async identify(userId, traits, options) {
+    const instance = AthenaTracker.getInstance();
+    const previousUserId = instance.state.userId; // Store anonymous ID for mapping
+    instance.state.userId = userId;
+    // Hash PII for custom audience building if requested
+    const hashedTraits = {
+      ...traits
+    };
+    if (options?.hashPII && traits) {
+      if (traits.email) {
+        hashedTraits.email_sha256 = await instance.hashPII(traits.email);
+      }
+      if (traits.phone) {
+        hashedTraits.phone_sha256 = await instance.hashPII(traits.phone);
+      }
+    }
+    AthenaTracker.track('identify', {
+      user_id: userId,
+      anonymous_id: previousUserId,
+      // Map anonymous → identified user
+      ...hashedTraits,
+      // Include external IDs for audience sync
+      external_ids: Object.keys(instance.externalIds).length > 0 ? instance.externalIds : undefined
+    });
+    console.log(`[ATHENA] User identified: ${userId}` + (previousUserId?.startsWith('anon_') ? ` (was ${previousUserId})` : ''));
+  }
+  /**
+   * Track an event
+   */
+  static track(eventType, properties) {
+    const instance = AthenaTracker.getInstance();
+    if (!instance.state.initialized) {
+      console.warn('[ATHENA] Tracker not initialized. Call init() first.');
+      return;
+    }
+    const event = {
+      event_type: eventType,
+      timestamp: Date.now(),
+      properties: properties || {},
+      session_id: instance.state.sessionId || undefined,
+      user_id: instance.state.userId || undefined
+    };
+    instance.state.events.push(event);
+    if (instance.config?.debug) {
+      console.log('[ATHENA] Event tracked:', event);
+    }
+    // Trigger immediate inference if batch size reached
+    if (instance.state.events.length >= instance.config.batching.size) {
+      instance.processBatch();
+    }
+  }
+  /**
+   * Process event batch and run inference
+   */
+  async processBatch() {
+    if (this.state.events.length === 0) return;
+    // Skip inference if too many consecutive failures
+    if (this.failureCount >= this.maxFailures) {
+      if (this.config?.debug) {
+        console.warn(`[ATHENA] Skipping inference after ${this.failureCount} consecutive failures. Will retry after ${this.maxFailures} successful events.`);
+      }
+      // Reset failure count after clearing queue
+      this.failureCount = Math.max(0, this.failureCount - 1);
+      this.state.events = []; // Drop events to prevent infinite buildup
+      return;
+    }
+    const events = [...this.state.events];
+    this.state.events = [];
+    try {
+      const prediction = await this.runInference(events);
+      this.failureCount = 0; // Reset on success
+      if (this.config?.webhook?.enabled && this.config.webhook.url) {
+        await this.sendWebhook(prediction);
+      }
+      if (this.config?.debug) {
+        console.log('[ATHENA] Prediction:', prediction);
+      }
+    } catch (error) {
+      this.failureCount++;
+      console.error(`[ATHENA] Failed to process batch (${this.failureCount}/${this.maxFailures}):`, error.message || error);
+      // Only re-queue if below failure threshold
+      if (this.failureCount < this.maxFailures) {
+        this.state.events.unshift(...events);
+      } else {
+        console.warn('[ATHENA] Max failures reached. Dropping events and disabling inference temporarily.');
+      }
+    }
+  }
+  /**
+   * Run inference (delegates to on-device or server)
+   */
+  async runInference(events) {
+    if (this.state.inferenceMode === 'on-device' && this.onDeviceInference) {
+      // Extract features from events (simplified - would need proper feature extraction)
+      const features = this.extractFeatures(events);
+      return await this.onDeviceInference.predict(features);
+    } else if (this.state.inferenceMode === 'server' && this.serverInference) {
+      return await this.serverInference.predict(events, this.state.sessionId || undefined, this.state.userId || undefined);
+    } else {
+      throw new Error('No inference engine available');
+    }
+  }
+  /**
+   * Extract features from events (placeholder)
+   * In production, this would use proper feature engineering
+   */
+  extractFeatures(events) {
+    // Simplified feature extraction - 20 features
+    const features = new Float32Array(20);
+    // Event count
+    features[0] = events.length;
+    // Unique event types
+    const uniqueTypes = new Set(events.map(e => e.event_type));
+    features[1] = uniqueTypes.size;
+    // Time span
+    if (events.length > 1) {
+      const timeSpan = events[events.length - 1].timestamp - events[0].timestamp;
+      features[2] = timeSpan / 1000; // seconds
+    }
+    // Fill remaining features with event type frequencies
+    const typeCounts = new Map();
+    events.forEach(e => {
+      typeCounts.set(e.event_type, (typeCounts.get(e.event_type) || 0) + 1);
+    });
+    let idx = 3;
+    ['click', 'scroll', 'page_view', 'cart_add', 'checkout_start'].forEach(type => {
+      features[idx++] = typeCounts.get(type) || 0;
+    });
+    return features;
+  }
+  /**
+   * Send prediction to webhook
+   */
+  async sendWebhook(prediction) {
+    if (!this.config?.webhook?.url) return;
+    const maxAttempts = this.config.webhook.retry?.maxAttempts || 3;
+    const backoffMs = this.config.webhook.retry?.backoffMs || 1000;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const response = await fetch(this.config.webhook.url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-App-Token': this.config.appToken
+          },
+          body: JSON.stringify({
+            ...prediction,
+            session_id: this.state.sessionId,
+            user_id: this.state.userId,
+            // Include external IDs for custom audience building
+            external_ids: Object.keys(this.externalIds).length > 0 ? this.externalIds : undefined
+          })
+        });
+        if (response.ok) {
+          if (this.config.debug) {
+            console.log('[ATHENA] Webhook delivered successfully');
+          }
+          return;
         }
-        return null;
-    }
-    /**
-     * Get current user ID
-     */
-    getUserId() {
-        const tracker = this.getTracker();
-        if (tracker && tracker.getUserId) {
-            return tracker.getUserId();
+        throw new Error(`Webhook failed: ${response.status}`);
+      } catch (error) {
+        console.warn(`[ATHENA] Webhook attempt ${attempt}/${maxAttempts} failed:`, error);
+        if (attempt < maxAttempts) {
+          await this.sleep(backoffMs * Math.pow(2, attempt - 1));
         }
-        return null;
+      }
+    }
+    console.error('[ATHENA] Webhook delivery failed after all retries');
+  }
+  /**
+   * Start event batching interval
+   */
+  startBatching() {
+    this.batchIntervalId = setInterval(() => {
+      this.processBatch();
+    }, this.config.batching.intervalMs);
+  }
+  /**
+   * Get inference mode
+   */
+  static getInferenceMode() {
+    return AthenaTracker.getInstance().state.inferenceMode;
+  }
+  /**
+   * Get session ID
+   */
+  static getSessionId() {
+    return AthenaTracker.getInstance().state.sessionId;
+  }
+  /**
+   * Cleanup resources
+   */
+  static async dispose() {
+    const instance = AthenaTracker.getInstance();
+    if (instance.batchIntervalId) {
+      clearInterval(instance.batchIntervalId);
+      instance.batchIntervalId = null;
+    }
+    if (instance.onDeviceInference) {
+      await instance.onDeviceInference.dispose();
+      instance.onDeviceInference = null;
     }
+    instance.serverInference = null;
+    instance.config = null;
+    instance.state = {
+      initialized: false,
+      inferenceMode: null,
+      sessionId: null,
+      userId: null,
+      events: []
+    };
+    console.log('[ATHENA] Tracker disposed');
+  }
+  /**
+   * Generate session ID
+   */
+  generateSessionId() {
+    return `sess_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+  }
+  /**
+   * Generate anonymous user ID compatible with Meta/Google standards
+   * Format: anon_{timestamp}_{random} for Pascal internal use
+   * Can be mapped to hashed PII for custom audience building
+   */
+  generateAnonymousId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 11);
+    return `anon_${timestamp}_${random}`;
+  }
+  /**
+   * Capture external IDs from Meta and Google for custom audience building
+   * Only works in browser environment with cookies
+   */
+  captureExternalIds() {
+    // Skip if not in browser environment
+    if (typeof document === 'undefined' || typeof document.cookie === 'undefined') {
+      return;
+    }
+    try {
+      const cookies = document.cookie.split(';').reduce((acc, cookie) => {
+        const [key, value] = cookie.trim().split('=');
+        acc[key] = value;
+        return acc;
+      }, {});
+      // Meta Pixel ID (_fbp) - Format: fb.{version}.{timestamp}.{random}
+      if (cookies._fbp) {
+        this.externalIds.fbp = cookies._fbp;
+      }
+      // Meta Click ID (_fbc) - Format: fb.{version}.{timestamp}.{click_id}
+      if (cookies._fbc) {
+        this.externalIds.fbc = cookies._fbc;
+      }
+      // Google Analytics Client ID (_ga) - Format: GA1.{version}.{random}.{timestamp}
+      if (cookies._ga) {
+        this.externalIds.ga = cookies._ga;
+      }
+      // Google Click ID (gcl_aw) - For Google Ads conversions
+      if (cookies.gcl_aw) {
+        this.externalIds.gclid = cookies.gcl_aw;
+      }
+      if (this.config?.debug && Object.keys(this.externalIds).length > 0) {
+        console.log('[ATHENA] External IDs captured for audience building:', this.externalIds);
+      }
+    } catch (error) {
+      console.warn('[ATHENA] Failed to capture external IDs:', error);
+    }
+  }
+  /**
+   * Hash PII for custom audience matching (SHA-256)
+   * Use this when user identifies with email/phone
+   */
+  async hashPII(value) {
+    // Normalize: lowercase, trim whitespace
+    const normalized = value.toLowerCase().trim();
+    // Use Web Crypto API for hashing (browser/modern Node)
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(normalized);
+      const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    // Try expo-crypto for React Native (Expo)
+    try {
+      // @ts-expect-error - expo-crypto is an optional peer dependency
+      const Crypto = await import('expo-crypto');
+      const hash = await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, normalized);
+      return hash;
+    } catch (error) {
+      // expo-crypto not available
+    }
+    // Fallback: return unhashed (server should hash it)
+    console.warn('[ATHENA] SHA-256 not available - install expo-crypto for React Native: npx expo install expo-crypto');
+    return normalized;
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+AthenaTracker.instance = null;
+
+/**
+ * Webhook Utilities
+ *
+ * Production-ready webhook system with HMAC signature verification
+ * Per ATHENA Integration Plan Phase 4.1
+ */
+// Cross-platform crypto support
+let crypto$1;
+try {
+  // Node.js environment
+  crypto$1 = require('crypto');
+} catch {
+  // Browser/React Native - will use Web Crypto API
+  crypto$1 = null;
+}
+/**
+ * Generate HMAC-SHA256 signature for webhook payload (Node.js version)
+ *
+ * @param payload - Webhook payload object
+ * @param secret - Webhook secret key
+ * @returns HMAC signature (hex-encoded)
+ */
+function generateWebhookSignatureNode(payload, secret) {
+  const payloadString = JSON.stringify(payload);
+  const hmac = crypto$1.createHmac('sha256', secret);
+  hmac.update(payloadString);
+  return hmac.digest('hex');
+}
+/**
+ * Generate HMAC-SHA256 signature for webhook payload (Web Crypto API version)
+ *
+ * @param payload - Webhook payload object
+ * @param secret - Webhook secret key
+ * @returns HMAC signature (hex-encoded)
+ */
+async function generateWebhookSignatureBrowser(payload, secret) {
+  const payloadString = JSON.stringify(payload);
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(secret);
+  const messageData = encoder.encode(payloadString);
+  // Import key for HMAC
+  const key = await globalThis.crypto.subtle.importKey('raw', keyData, {
+    name: 'HMAC',
+    hash: 'SHA-256'
+  }, false, ['sign']);
+  // Generate signature
+  const signature = await globalThis.crypto.subtle.sign('HMAC', key, messageData);
+  // Convert to hex
+  return Array.from(new Uint8Array(signature)).map(b => b.toString(16).padStart(2, '0')).join('');
 }
-// Singleton instance
-let trackerInstance = null;
 /**
- * Initialize ATHENA tracker
+ * Generate HMAC-SHA256 signature for webhook payload (cross-platform)
+ *
+ * @param payload - Webhook payload object
+ * @param secret - Webhook secret key
+ * @returns HMAC signature (hex-encoded)
  */
-function initTracker(config) {
-    if (!trackerInstance) {
-        trackerInstance = new AthenaTrackerSDK(config);
+async function generateWebhookSignature(payload, secret) {
+  if (crypto$1) {
+    // Node.js environment
+    return generateWebhookSignatureNode(payload, secret);
+  } else if (typeof globalThis !== 'undefined' && globalThis.crypto?.subtle) {
+    // Browser/Web Crypto API
+    return await generateWebhookSignatureBrowser(payload, secret);
+  } else {
+    // No crypto available - return empty signature
+    console.warn('[ATHENA] Crypto API not available - webhook signatures disabled');
+    return '';
+  }
+}
+/**
+ * Verify webhook signature (for use on receiving end)
+ *
+ * @param payload - Webhook payload object
+ * @param signature - Received signature (from X-ATHENA-Signature header)
+ * @param secret - Webhook secret key
+ * @returns True if signature is valid
+ */
+async function verifyWebhookSignature(payload, signature, secret) {
+  const expectedSignature = await generateWebhookSignature(payload, secret);
+  if (!expectedSignature) {
+    // Crypto not available - skip verification
+    return true;
+  }
+  // Use timing-safe comparison to prevent timing attacks (Node.js only)
+  if (crypto$1 && crypto$1.timingSafeEqual) {
+    try {
+      return crypto$1.timingSafeEqual(Buffer.from(signature, 'hex'), Buffer.from(expectedSignature, 'hex'));
+    } catch (error) {
+      return false;
     }
-    return trackerInstance;
+  }
+  // Browser fallback - simple comparison (not timing-safe)
+  return signature === expectedSignature;
 }
 /**
- * Get the tracker instance
+ * Create webhook payload for prediction update
  */
-function getTracker() {
-    if (!trackerInstance) {
-        console.warn('ATHENA Tracker: not initialized. Call initTracker() first.');
+function createPredictionPayload(appId, userId, sessionId, prediction) {
+  return {
+    event: 'prediction_update',
+    appId,
+    timestamp: new Date().toISOString(),
+    data: {
+      user_id: userId,
+      session_id: sessionId,
+      ...prediction
     }
-    return trackerInstance;
+  };
 }
 /**
- * Convenience methods (use singleton instance)
+ * Create webhook payload for segment update
  */
-function identify(userId, properties) {
-    trackerInstance?.identify(userId, properties);
+function createSegmentUpdatePayload(appId, segment, userCount, users) {
+  return {
+    event: 'segment_update',
+    appId,
+    timestamp: new Date().toISOString(),
+    data: {
+      segment,
+      user_count: userCount,
+      users
+    }
+  };
 }
-function track(eventName, properties) {
-    trackerInstance?.track(eventName, properties);
+/**
+ * Create webhook payload for friction detection
+ */
+function createFrictionPayload(appId, frictionType, screen, selector, affectedUsers) {
+  return {
+    event: 'friction_detected',
+    appId,
+    timestamp: new Date().toISOString(),
+    data: {
+      type: frictionType,
+      screen,
+      selector,
+      affected_users: affectedUsers,
+      severity: affectedUsers > 100 ? 'high' : affectedUsers > 50 ? 'medium' : 'low'
+    }
+  };
 }
-function page(pageName, properties) {
-    trackerInstance?.page(pageName, properties);
+/**
+ * Create webhook payload for conversion event
+ */
+function createConversionPayload(appId, userId, sessionId, conversionType, value, metadata) {
+  return {
+    event: 'conversion',
+    appId,
+    timestamp: new Date().toISOString(),
+    data: {
+      user_id: userId,
+      session_id: sessionId,
+      conversion_type: conversionType,
+      value,
+      ...metadata
+    }
+  };
 }
-function reset() {
-    trackerInstance?.reset();
+/**
+ * Webhook delivery with retry logic and exponential backoff
+ *
+ * @param url - Webhook URL
+ * @param payload - Webhook payload
+ * @param secret - Webhook secret for signature (optional)
+ * @param options - Delivery options
+ * @returns Delivery result
+ */
+async function deliverWebhook(url, payload, secret, options = {}) {
+  const maxAttempts = options.maxAttempts || 3;
+  const backoffMs = options.backoffMs || 1000;
+  const timeoutMs = options.timeoutMs || 5000;
+  const signature = secret ? await generateWebhookSignature(payload, secret) : '';
+  const startTime = Date.now();
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-ATHENA-Signature': signature,
+          'X-ATHENA-Event': payload.event,
+          'X-ATHENA-Timestamp': payload.timestamp
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        const latencyMs = Date.now() - startTime;
+        return {
+          success: true,
+          attempts: attempt,
+          latencyMs
+        };
+      }
+      lastError = `HTTP ${response.status}: ${response.statusText}`;
+    } catch (error) {
+      lastError = error.name === 'AbortError' ? `Timeout after ${timeoutMs}ms` : error.message || 'Unknown error';
+    }
+    // Wait before retry (exponential backoff)
+    if (attempt < maxAttempts) {
+      const delayMs = backoffMs * Math.pow(2, attempt - 1);
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+    }
+  }
+  const latencyMs = Date.now() - startTime;
+  return {
+    success: false,
+    attempts: maxAttempts,
+    latencyMs,
+    error: lastError
+  };
+}
+/**
+ * Validate webhook payload structure
+ */
+function isValidWebhookPayload(payload) {
+  if (typeof payload !== 'object' || payload === null) return false;
+  const validEvents = ['prediction_update', 'segment_update', 'friction_detected', 'conversion', 'session_end'];
+  return typeof payload.event === 'string' && validEvents.includes(payload.event) && typeof payload.appId === 'string' && typeof payload.timestamp === 'string' && typeof payload.data === 'object' && payload.data !== null;
 }
-function getSessionId() {
-    return trackerInstance?.getSessionId() || null;
+
+/**
+ * ATHENA OTA Wrapper
+ *
+ * Wraps the React Native app and forces a reload on first launch after OTA update
+ * This ensures the ATHENA tracker is loaded fresh after deployment
+ *
+ * Usage:
+ *   import { AthenaOTAWrapper } from '@athena/tracker';
+ *
+ *   export default function App() {
+ *     return (
+ *       <AthenaOTAWrapper>
+ *         <YourAppContent />
+ *       </AthenaOTAWrapper>
+ *     );
+ *   }
+ */
+// Dynamic import of expo-updates (optional peer dependency)
+let Updates = null;
+async function loadExpoUpdates() {
+  try {
+    Updates = await import('expo-updates');
+    return true;
+  } catch (error) {
+    console.warn('[ATHENA] expo-updates not available - OTA updates disabled');
+    return false;
+  }
 }
-function getUserId() {
-    return trackerInstance?.getUserId() || null;
+function AthenaOTAWrapper({
+  children,
+  loadingMessage = 'Loading...',
+  updateMessage = 'Updating...'
+}) {
+  const [isCheckingUpdate, setIsCheckingUpdate] = React.useState(true);
+  const [updateAvailable, setUpdateAvailable] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  React.useEffect(() => {
+    checkForUpdates();
+  }, []);
+  async function checkForUpdates() {
+    try {
+      // Load expo-updates module
+      const hasUpdates = await loadExpoUpdates();
+      if (!hasUpdates) {
+        // expo-updates not available, continue without OTA check
+        setIsCheckingUpdate(false);
+        return;
+      }
+      // Check if running in development mode (skip update check)
+      if (__DEV__) {
+        console.log('[ATHENA] Development mode - skipping OTA update check');
+        setIsCheckingUpdate(false);
+        return;
+      }
+      console.log('[ATHENA] Checking for OTA updates...');
+      // Check for available updates
+      const update = await Updates.checkForUpdateAsync();
+      if (update.isAvailable) {
+        console.log('[ATHENA] Update available - fetching...');
+        setUpdateAvailable(true);
+        // Fetch the new update
+        await Updates.fetchUpdateAsync();
+        console.log('[ATHENA] Update fetched - reloading app...');
+        // Force reload to apply update
+        await Updates.reloadAsync();
+        // If reloadAsync fails, we'll never reach here
+      } else {
+        console.log('[ATHENA] No updates available - continuing with current version');
+        setIsCheckingUpdate(false);
+      }
+    } catch (error) {
+      // Don't block app if update check fails
+      console.warn('[ATHENA] Update check failed:', error.message);
+      setError(error.message);
+      setIsCheckingUpdate(false);
+    }
+  }
+  // Show loading screen while checking for updates
+  if (isCheckingUpdate || updateAvailable) {
+    return React.createElement(reactNative.View, {
+      style: styles.container
+    }, React.createElement(reactNative.ActivityIndicator, {
+      size: "large",
+      color: "#007AFF"
+    }), React.createElement(reactNative.Text, {
+      style: styles.text
+    }, updateAvailable ? updateMessage : loadingMessage), error && React.createElement(reactNative.Text, {
+      style: styles.errorText
+    }, "Update check failed: ", error));
+  }
+  // Render app content once update check is complete
+  return React.createElement(React.Fragment, null, children);
 }
-// Default export
-var index = {
-    initTracker,
-    getTracker,
-    identify,
-    track,
-    page,
-    reset,
-    getSessionId,
-    getUserId,
-};
+const styles = reactNative.StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    backgroundColor: '#FFFFFF'
+  },
+  text: {
+    marginTop: 16,
+    color: '#666666',
+    fontSize: 14,
+    fontWeight: '500'
+  },
+  errorText: {
+    marginTop: 8,
+    color: '#FF3B30',
+    fontSize: 12,
+    textAlign: 'center',
+    paddingHorizontal: 32
+  }
+});
+
+/**
+ * React Native Event Capture
+ *
+ * Captures behavioral events from React Native apps
+ * - Touch events (Tap, Swipe, LongPress)
+ * - Navigation events (Screen changes)
+ * - App lifecycle events (Open, Background, Foreground, Close)
+ * - Form interactions
+ * - Network errors
+ */
+class ReactNativeEventCapture {
+  constructor(config = {}) {
+    this.events = [];
+    this.appStateSubscription = null;
+    this.panResponder = null;
+    this.batchTimer = null;
+    this.currentScreen = 'Unknown';
+    this.sessionStartTime = Date.now();
+    this.config = {
+      captureTouch: config.captureTouch !== false,
+      captureNavigation: config.captureNavigation !== false,
+      captureLifecycle: config.captureLifecycle !== false,
+      captureNetworkErrors: config.captureNetworkErrors !== false,
+      batchSize: config.batchSize || 10,
+      batchIntervalMs: config.batchIntervalMs || 10000
+    };
+  }
+  /**
+   * Start capturing events
+   */
+  start() {
+    console.log('[ATHENA] Starting React Native event capture');
+    if (this.config.captureLifecycle) {
+      this.setupLifecycleTracking();
+    }
+    if (this.config.captureTouch) {
+      this.setupTouchTracking();
+    }
+    if (this.config.captureNetworkErrors) {
+      this.setupNetworkErrorTracking();
+    }
+    // Start batch timer
+    this.batchTimer = setInterval(() => {
+      this.flushEvents();
+    }, this.config.batchIntervalMs);
+    // Capture initial AppOpen event
+    this.captureEvent({
+      event_type: 'AppOpen',
+      timestamp: Date.now(),
+      properties: {
+        screen: this.currentScreen,
+        session_start: true
+      }
+    });
+  }
+  /**
+   * Stop capturing events
+   */
+  stop() {
+    console.log('[ATHENA] Stopping React Native event capture');
+    if (this.appStateSubscription) {
+      this.appStateSubscription.remove();
+    }
+    if (this.batchTimer) {
+      clearInterval(this.batchTimer);
+    }
+    // Flush any remaining events
+    this.flushEvents();
+  }
+  /**
+   * Setup app lifecycle tracking (Open, Background, Foreground, Close)
+   */
+  setupLifecycleTracking() {
+    this.appStateSubscription = reactNative.AppState.addEventListener('change', nextAppState => {
+      if (nextAppState === 'active') {
+        this.captureEvent({
+          event_type: 'AppForeground',
+          timestamp: Date.now(),
+          properties: {
+            screen: this.currentScreen
+          }
+        });
+      } else if (nextAppState === 'background') {
+        this.captureEvent({
+          event_type: 'AppBackground',
+          timestamp: Date.now(),
+          properties: {
+            screen: this.currentScreen,
+            session_duration: Date.now() - this.sessionStartTime
+          }
+        });
+      } else if (nextAppState === 'inactive') {
+        this.captureEvent({
+          event_type: 'AppInactive',
+          timestamp: Date.now(),
+          properties: {
+            screen: this.currentScreen
+          }
+        });
+      }
+    });
+  }
+  /**
+   * Setup touch event tracking
+   */
+  setupTouchTracking() {
+    let touchStartTime = 0;
+    this.panResponder = reactNative.PanResponder.create({
+      onStartShouldSetPanResponder: () => true,
+      onMoveShouldSetPanResponder: () => true,
+      onPanResponderGrant: (_evt, _gestureState) => {
+        touchStartTime = Date.now();
+      },
+      onPanResponderRelease: (evt, gestureState) => {
+        const touchDuration = Date.now() - touchStartTime;
+        const deltaX = Math.abs(gestureState.dx);
+        const deltaY = Math.abs(gestureState.dy);
+        // Detect gesture type
+        if (touchDuration > 500 && deltaX < 10 && deltaY < 10) {
+          // Long press
+          this.captureEvent({
+            event_type: 'LongPress',
+            timestamp: Date.now(),
+            properties: {
+              screen: this.currentScreen,
+              x: evt.nativeEvent.pageX,
+              y: evt.nativeEvent.pageY,
+              duration: touchDuration
+            }
+          });
+        } else if (deltaX > 50 || deltaY > 50) {
+          // Swipe
+          const direction = deltaX > deltaY ? gestureState.dx > 0 ? 'right' : 'left' : gestureState.dy > 0 ? 'down' : 'up';
+          this.captureEvent({
+            event_type: 'Swipe',
+            timestamp: Date.now(),
+            properties: {
+              screen: this.currentScreen,
+              direction,
+              distance: Math.sqrt(deltaX * deltaX + deltaY * deltaY)
+            }
+          });
+        } else {
+          // Tap
+          this.captureEvent({
+            event_type: 'Tap',
+            timestamp: Date.now(),
+            properties: {
+              screen: this.currentScreen,
+              x: evt.nativeEvent.pageX,
+              y: evt.nativeEvent.pageY,
+              duration: touchDuration
+            }
+          });
+        }
+      }
+    });
+  }
+  /**
+   * Setup network error tracking
+   */
+  setupNetworkErrorTracking() {
+    // Monkey-patch fetch to track network errors
+    const originalFetch = global.fetch;
+    global.fetch = async (input, init) => {
+      const startTime = Date.now();
+      const url = typeof input === 'string' ? input : input.url || String(input);
+      try {
+        const response = await originalFetch(input, init);
+        if (!response.ok) {
+          this.captureEvent({
+            event_type: 'NetworkError',
+            timestamp: Date.now(),
+            properties: {
+              screen: this.currentScreen,
+              url,
+              status: response.status,
+              statusText: response.statusText,
+              duration: Date.now() - startTime
+            }
+          });
+        }
+        return response;
+      } catch (error) {
+        this.captureEvent({
+          event_type: 'NetworkError',
+          timestamp: Date.now(),
+          properties: {
+            screen: this.currentScreen,
+            url,
+            error: error.message,
+            duration: Date.now() - startTime
+          }
+        });
+        throw error;
+      }
+    };
+  }
+  /**
+   * Manually track screen navigation
+   * Should be called by navigation library (React Navigation, etc.)
+   */
+  trackScreenView(screenName, params) {
+    this.currentScreen = screenName;
+    this.captureEvent({
+      event_type: 'ScreenView',
+      timestamp: Date.now(),
+      properties: {
+        screen: screenName,
+        params: params || {},
+        previous_screen: this.currentScreen
+      }
+    });
+  }
+  /**
+   * Manually track custom event
+   */
+  track(eventType, properties) {
+    this.captureEvent({
+      event_type: eventType,
+      timestamp: Date.now(),
+      properties: {
+        ...properties,
+        screen: this.currentScreen
+      }
+    });
+  }
+  /**
+   * Capture an event and add to batch
+   */
+  captureEvent(event) {
+    this.events.push(event);
+    // Flush immediately if batch size reached
+    if (this.events.length >= this.config.batchSize) {
+      this.flushEvents();
+    }
+  }
+  /**
+   * Flush accumulated events (to be sent to server)
+   */
+  flushEvents() {
+    if (this.events.length === 0) return;
+    const batch = [...this.events];
+    this.events = [];
+    // Emit events for tracker to send
+    this.onEventBatch?.(batch);
+  }
+  /**
+   * Get PanResponder for manual integration
+   * Usage: <View {...capture.getPanResponderProps()}>
+   */
+  getPanResponderProps() {
+    return this.panResponder?.panHandlers || {};
+  }
+}
+
+/**
+ * @athena/tracker
+ *
+ * Behavioral analytics tracker with edge AI
+ */
+// Version
+const VERSION = '1.0.0';
 
-exports.default = index;
-exports.getSessionId = getSessionId;
-exports.getTracker = getTracker;
-exports.getUserId = getUserId;
-exports.identify = identify;
-exports.initTracker = initTracker;
-exports.page = page;
-exports.reset = reset;
-exports.track = track;
+exports.AthenaOTAWrapper = AthenaOTAWrapper;
+exports.AthenaTracker = AthenaTracker;
+exports.ReactNativeEventCapture = ReactNativeEventCapture;
+exports.VERSION = VERSION;
+exports.createConversionPayload = createConversionPayload;
+exports.createFrictionPayload = createFrictionPayload;
+exports.createPredictionPayload = createPredictionPayload;
+exports.createSegmentUpdatePayload = createSegmentUpdatePayload;
+exports.default = AthenaTracker;
+exports.deliverWebhook = deliverWebhook;
+exports.detectInferenceMode = detectInferenceMode;
+exports.generateWebhookSignature = generateWebhookSignature;
+exports.getPlatform = getPlatform;
+exports.isBrowser = isBrowser;
+exports.isReactNative = isReactNative;
+exports.isValidWebhookPayload = isValidWebhookPayload;
+exports.verifyWebhookSignature = verifyWebhookSignature;
 //# sourceMappingURL=index.js.map