@athena-tracker/tracker 1.2.0 → 1.3.0

package/dist/index.esm.js

@@ -5,7 +5,7 @@ import { StyleSheet, View, ActivityIndicator, Text, AppState, PanResponder } fro
  * Auto-Detection Logic
  *
  * Automatically detects whether to use on-device or server-side inference
- * based on availability of onnxruntime-react-native
+ * based on availability of onnxruntime-web (browser) or onnxruntime-react-native (RN)
  */
 async function detectInferenceMode(configMode) {
   // Respect explicit configuration
@@ -17,14 +17,31 @@ async function detectInferenceMode(configMode) {
     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)');
+  // Auto-detect based on platform and ONNX runtime availability
+  const platform = getPlatform();
+  if (platform === 'web') {
+    // Try to load onnxruntime-web for browsers
+    try {
+      await import('onnxruntime-web');
+      console.log('[ATHENA] On-device inference available (onnxruntime-web detected)');
+      return 'on-device';
+    } catch (error) {
+      console.log('[ATHENA] Falling back to server-side inference (onnxruntime-web not found)');
+      return 'server';
+    }
+  } else if (platform === 'react-native') {
+    // Try to load onnxruntime-react-native for React Native
+    try {
+      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';
+    }
+  } else {
+    // Unknown platform - use server-side inference
+    console.log('[ATHENA] Falling back to server-side inference (unknown platform)');
     return 'server';
   }
 }
@@ -58,14 +75,14 @@ function getPlatform() {
  * Uses onnxruntime-react-native for local ML inference
  * Target latency: <10ms P95
  */
-let InferenceSession;
-let Tensor;
+let InferenceSession$1;
+let Tensor$1;
 // 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;
+    InferenceSession$1 = onnx.InferenceSession;
+    Tensor$1 = onnx.Tensor;
     return true;
   } catch (error) {
     console.error('[ATHENA] Failed to load onnxruntime-react-native:', error);
@@ -89,7 +106,7 @@ class OnDeviceInference {
     }
     try {
       const startTime = performance.now();
-      this.session = await InferenceSession.create(modelPath);
+      this.session = await InferenceSession$1.create(modelPath);
       const loadTime = performance.now() - startTime;
       this.modelLoaded = true;
       console.log(`[ATHENA] ONNX model loaded successfully (${loadTime.toFixed(0)}ms)`);
@@ -108,7 +125,7 @@ class OnDeviceInference {
     const startTime = performance.now();
     try {
       // Create input tensor
-      const inputTensor = new Tensor('float32', features, [1, features.length]);
+      const inputTensor = new Tensor$1('float32', features, [1, features.length]);
       const feeds = {
         input: inputTensor
       };
@@ -234,6 +251,192 @@ class OnDeviceInference {
   }
 }
 
+/**
+ * On-Device Inference Module (Web Browser)
+ *
+ * Uses onnxruntime-web for browser-based ML inference
+ * Target latency: <3ms P95
+ */
+let InferenceSession;
+let Tensor;
+// Dynamically import ONNX Runtime Web (only available in browsers)
+async function loadOnnxRuntimeWeb() {
+  try {
+    const onnx = await import('onnxruntime-web');
+    InferenceSession = onnx.InferenceSession;
+    Tensor = onnx.Tensor;
+    return true;
+  } catch (error) {
+    console.error('[ATHENA] Failed to load onnxruntime-web:', error);
+    return false;
+  }
+}
+class OnDeviceInferenceWeb {
+  constructor() {
+    this.session = null;
+    this.modelLoaded = false;
+  }
+  /**
+   * Initialize ONNX session with model file
+   */
+  async initialize(modelPath) {
+    console.log('[ATHENA] Loading ONNX model for browser inference...');
+    // Load ONNX Runtime Web
+    const loaded = await loadOnnxRuntimeWeb();
+    if (!loaded) {
+      throw new Error('onnxruntime-web not available');
+    }
+    try {
+      const startTime = performance.now();
+      this.session = await InferenceSession.create(modelPath, {
+        executionProviders: ['wasm'],
+        // Use WebAssembly backend
+        graphOptimizationLevel: 'all'
+      });
+      const loadTime = performance.now() - startTime;
+      this.modelLoaded = true;
+      console.log(`[ATHENA] ONNX model loaded successfully in browser (${loadTime.toFixed(0)}ms)`);
+    } catch (error) {
+      console.error('[ATHENA] Failed to load ONNX model:', error);
+      throw new Error(`Model loading failed: ${error}`);
+    }
+  }
+  /**
+   * Run inference on feature vector
+   */
+  async predict(features) {
+    if (!this.modelLoaded || !this.session) {
+      throw new Error('ONNX model not initialized. Call initialize() first.');
+    }
+    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] Browser 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] Browser inference failed:', error);
+      throw new Error(`Inference failed: ${error}`);
+    }
+  }
+  /**
+   * 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';
+    }
+    // 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)}%)`
+      };
+    }
+    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] Browser inference session disposed');
+      } catch (error) {
+        console.warn('[ATHENA] Failed to dispose session:', error);
+      }
+      this.session = null;
+      this.modelLoaded = false;
+    }
+  }
+}
+
 /**
  * Server-Side Inference Module
  *
@@ -314,12 +517,17 @@ class ServerInference {
     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'
-      }, 10000); // Increased to 10s for mobile networks
+      }, 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);
+      console.warn('[ATHENA] Server connectivity test failed:', error.message || error);
+      console.warn('[ATHENA] URL attempted:', this.apiUrl.replace('/v1/predict', '/health'));
       return false;
     }
   }
@@ -356,6 +564,10 @@ class AthenaTracker {
     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
   }
   /**
@@ -398,6 +610,10 @@ class AthenaTracker {
     }
     // 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;
@@ -408,7 +624,15 @@ class AthenaTracker {
    */
   async initializeOnDevice() {
     try {
-      this.onDeviceInference = new OnDeviceInference();
+      const platform = getPlatform();
+      // Use platform-specific ONNX runtime
+      if (platform === 'web') {
+        this.onDeviceInference = new OnDeviceInferenceWeb();
+      } else if (platform === 'react-native') {
+        this.onDeviceInference = new OnDeviceInference();
+      } else {
+        throw new Error('Unsupported platform for on-device inference');
+      }
       await this.onDeviceInference.initialize(this.config.modelPath);
       console.log('[ATHENA] On-device inference ready');
     } catch (error) {
@@ -422,7 +646,8 @@ class AthenaTracker {
    * Initialize server-side inference
    */
   async initializeServer() {
-    this.serverInference = new ServerInference(this.config.serverInferenceUrl, this.config.appToken);
+    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) {
@@ -433,15 +658,37 @@ class AthenaTracker {
   }
   /**
    * 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 identify(userId, traits) {
+  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,
-      ...traits
+      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}`);
+    console.log(`[ATHENA] User identified: ${userId}` + (previousUserId?.startsWith('anon_') ? ` (was ${previousUserId})` : ''));
   }
   /**
    * Track an event
@@ -473,10 +720,21 @@ class AthenaTracker {
    */
   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);
       }
@@ -484,9 +742,14 @@ class AthenaTracker {
         console.log('[ATHENA] Prediction:', prediction);
       }
     } catch (error) {
-      console.error('[ATHENA] Failed to process batch:', error);
-      // Re-queue events on failure
-      this.state.events.unshift(...events);
+      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.');
+      }
     }
   }
   /**
@@ -549,7 +812,9 @@ class AthenaTracker {
           body: JSON.stringify({
             ...prediction,
             session_id: this.state.sessionId,
-            user_id: this.state.userId
+            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) {
@@ -618,6 +883,82 @@ class AthenaTracker {
   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
    */
@@ -634,13 +975,13 @@ AthenaTracker.instance = null;
  * Per ATHENA Integration Plan Phase 4.1
  */
 // Cross-platform crypto support
-let crypto;
+let crypto$1;
 try {
   // Node.js environment
-  crypto = require('crypto');
+  crypto$1 = require('crypto');
 } catch {
   // Browser/React Native - will use Web Crypto API
-  crypto = null;
+  crypto$1 = null;
 }
 /**
  * Generate HMAC-SHA256 signature for webhook payload (Node.js version)
@@ -651,7 +992,7 @@ try {
  */
 function generateWebhookSignatureNode(payload, secret) {
   const payloadString = JSON.stringify(payload);
-  const hmac = crypto.createHmac('sha256', secret);
+  const hmac = crypto$1.createHmac('sha256', secret);
   hmac.update(payloadString);
   return hmac.digest('hex');
 }
@@ -685,7 +1026,7 @@ async function generateWebhookSignatureBrowser(payload, secret) {
  * @returns HMAC signature (hex-encoded)
  */
 async function generateWebhookSignature(payload, secret) {
-  if (crypto) {
+  if (crypto$1) {
     // Node.js environment
     return generateWebhookSignatureNode(payload, secret);
   } else if (typeof globalThis !== 'undefined' && globalThis.crypto?.subtle) {
@@ -712,9 +1053,9 @@ async function verifyWebhookSignature(payload, signature, secret) {
     return true;
   }
   // Use timing-safe comparison to prevent timing attacks (Node.js only)
-  if (crypto && crypto.timingSafeEqual) {
+  if (crypto$1 && crypto$1.timingSafeEqual) {
     try {
-      return crypto.timingSafeEqual(Buffer.from(signature, 'hex'), Buffer.from(expectedSignature, 'hex'));
+      return crypto$1.timingSafeEqual(Buffer.from(signature, 'hex'), Buffer.from(expectedSignature, 'hex'));
     } catch (error) {
       return false;
     }