cryptique-sdk 1.2.19 → 1.2.21

package/lib/cjs/index.js

@@ -92,8 +92,8 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
     // Geolocation API
     GEOLOCATION: {
-      PRIMARY_URL: "https://ipinfo.io/json?token=8fc6409059aa39",
-      BACKUP_URL: "https://ipinfo.io/json?token=8fc6409059aa39&http=1.1",
+      PRIMARY_URL: "https://ipinfo.io/json?token=3a0c034aefbef8",
+      BACKUP_URL: "https://ipinfo.io/json?token=3a0c034aefbef8&http=1.1",
       TIMEOUT_MS: 5000                                  // 5 second timeout
     },
 
@@ -1139,7 +1139,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
     isFirstPage: true,
     
     // JSONB fields
-    interactions: {},
     visited_pages: [],
     
     // Also stored in locationData object for structured access (backward compatibility)
@@ -2084,7 +2083,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       if (sessionData.utm_id === undefined) sessionData.utm_id = null;
       
       // JSONB fields
-      if (!sessionData.interactions) sessionData.interactions = {};
       if (!sessionData.visited_pages) sessionData.visited_pages = [];
       
       // Internal tracking
@@ -2149,8 +2147,7 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         // UTM fields (already snake_case, no mapping needed)
         
         // JSONB fields
-        'visited_pages': 'visited_pages',  // Already snake_case
-        'interactions': 'interactions'     // Already snake_case
+        'visited_pages': 'visited_pages'   // Already snake_case
       };
       
       return fieldMap[internalName] || this.toSnakeCase(internalName);
@@ -3194,333 +3191,24 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
     }
   };
 
-  // ============================================================================
-  // SECTION 10: INTERACTION MANAGEMENT
-  // ============================================================================
-  // PURPOSE: Single source of truth for interaction tracking and management.
-  //          Handles all user interactions (clicks, forms, scroll, hover, etc.)
-  //
-  // KEY PRINCIPLES:
-  // 1. All interactions stored in categorized structure
-  // 2. Automatic timestamp addition
-  // 3. Total interactions count maintained
-  // 4. Chronological sorting for backend
-  // 5. Immediate session storage updates
-  // 6. Prevents duplicate interactions
-  //
-  // BENEFITS:
-  // - Centralized interaction tracking
-  // - Consistent data structure
-  // - Single place to fix interaction bugs
-  // - Prevents repeating interactions
-  // ============================================================================
+  // SECTION 10: INTERACTION MANAGEMENT — REMOVED
+  // Interactions JSONB tracking has been removed from sessions.
+  // Important signals (clicks, errors, etc.) are captured as individual
+  // queryable auto events in the events table instead.
 
-  /**
-   * InteractionManager - Interaction tracking and management
-   * 
-   * This object handles all user interaction tracking, storage, and management
-   */
+  // No-op stub — all methods removed with interactions feature.
   const InteractionManager = {
-    /**
-     * Interaction categories
-     * 
-     * All supported interaction categories
-     */
-    CATEGORIES: [
-      'clicks',
-      'formInteractions',
-      'mediaInteractions',
-      'scrollEvents',
-      'focusEvents',
-      'hoverEvents',
-      'formSubmissions',
-      'fieldChanges',
-      'validationErrors',
-      'keyboardEvents',
-      'copyPasteEvents',
-      'contextMenuEvents',
-      'dragDropEvents',
-      'touchEvents',
-      'windowEvents',
-      'performanceEvents',
-      'errorEvents',
-      'networkEvents',
-      'formAnalytics'
-    ],
-
-    /**
-     * Initialize interactions structure
-     * 
-     * Creates empty interactions object with all categories
-     */
-    initialize() {
-      if (!sessionData.interactions || Object.keys(sessionData.interactions).length === 0) {
-        sessionData.interactions = {
-          totalInteractions: 0,
-          clicks: [],
-          formInteractions: [],
-          mediaInteractions: [],
-          scrollEvents: [],
-          focusEvents: [],
-          hoverEvents: [],
-          formSubmissions: [],
-          fieldChanges: [],
-          validationErrors: [],
-          keyboardEvents: [],
-          copyPasteEvents: [],
-          contextMenuEvents: [],
-          dragDropEvents: [],
-          touchEvents: [],
-          windowEvents: [],
-          performanceEvents: [],
-          errorEvents: [],
-          networkEvents: [],
-          formAnalytics: []
-        };
-      }
-    },
-
-    /**
-     * Add interaction to appropriate category
-     * 
-     * Logic:
-     * 1. Ensures interactions are initialized
-     * 2. Adds timestamp if not provided
-     * 3. Adds to specific category array
-     * 4. Updates total interactions count
-     * 5. Updates session activity
-     * 6. Immediately updates session storage
-     * 
-     * Parameters:
-     * - category: Interaction category (e.g., 'clicks', 'formInteractions')
-     * - interactionData: Interaction data object
-     */
-    add(category, interactionData) {
-      // Ensure interactions are initialized
-      this.initialize();
-
-      // Validate category
-      if (!this.CATEGORIES.includes(category)) {
-        return;
-      }
-
-      // Add timestamp if not provided
-      if (!interactionData.timestamp) {
-        interactionData.timestamp = nowIso();
-      }
-
-      // Add to specific category
-      if (sessionData.interactions[category]) {
-        sessionData.interactions[category].push(interactionData);
-      }
-
-      // Update total interactions count
-      this.updateTotalCount();
-
-      // Update last activity
-      sessionData.lastActivity = Date.now();
-
-      // Immediately update session storage
-      this.updateSessionStorage();
-    },
-
-    /**
-     * Update total interactions count
-     * 
-     * Calculates total from all category arrays
-     */
-    updateTotalCount() {
-      if (!sessionData.interactions) return;
-
-      let total = 0;
-      for (const category of this.CATEGORIES) {
-        if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-          total += sessionData.interactions[category].length;
-        }
-      }
-
-      sessionData.interactions.totalInteractions = total;
-    },
-
-    /**
-     * Update session storage with interactions
-     * 
-     * Immediately syncs interactions to session storage
-     */
-    updateSessionStorage() {
-      try {
-        const storedSession = StorageManager.loadSession();
-        if (storedSession && storedSession.sessionData) {
-          storedSession.sessionData.interactions = sessionData.interactions;
-          StorageManager.saveSession(storedSession);
-        }
-      } catch (error) {
-        }
-    },
-
-    /**
-     * Get all interactions sorted chronologically
-     * 
-     * Collects all interactions from all categories, adds category identifiers,
-     * and sorts by timestamp
-     * 
-     * Returns: Array of interactions sorted by timestamp
-     */
-    getChronological() {
-      if (!sessionData.interactions) {
-        return [];
-      }
-
-      const allInteractions = [];
-
-      // Map of category to category identifier
-      const categoryMap = {
-        'clicks': { category: 'click', originalCategory: 'clicks' },
-        'formInteractions': { category: 'formInteraction', originalCategory: 'formInteractions' },
-        'mediaInteractions': { category: 'mediaInteraction', originalCategory: 'mediaInteractions' },
-        'scrollEvents': { category: 'scrollEvent', originalCategory: 'scrollEvents' },
-        'focusEvents': { category: 'focusEvent', originalCategory: 'focusEvents' },
-        'hoverEvents': { category: 'hoverEvent', originalCategory: 'hoverEvents' },
-        'formSubmissions': { category: 'formSubmission', originalCategory: 'formSubmissions' },
-        'fieldChanges': { category: 'fieldChange', originalCategory: 'fieldChanges' },
-        'validationErrors': { category: 'validationError', originalCategory: 'validationErrors' },
-        'keyboardEvents': { category: 'keyboardEvent', originalCategory: 'keyboardEvents' },
-        'copyPasteEvents': { category: 'copyPasteEvent', originalCategory: 'copyPasteEvents' },
-        'contextMenuEvents': { category: 'contextMenuEvent', originalCategory: 'contextMenuEvents' },
-        'dragDropEvents': { category: 'dragDropEvent', originalCategory: 'dragDropEvents' },
-        'touchEvents': { category: 'touchEvent', originalCategory: 'touchEvents' },
-        'windowEvents': { category: 'windowEvent', originalCategory: 'windowEvents' },
-        'performanceEvents': { category: 'performanceEvent', originalCategory: 'performanceEvents' },
-        'errorEvents': { category: 'errorEvent', originalCategory: 'errorEvents' },
-        'networkEvents': { category: 'networkEvent', originalCategory: 'networkEvents' },
-        'formAnalytics': { category: 'formAnalytic', originalCategory: 'formAnalytics' }
-      };
-
-      // Collect all interactions from all categories
-      for (const category of this.CATEGORIES) {
-        if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-          const categoryInfo = categoryMap[category];
-          sessionData.interactions[category].forEach(interaction => {
-            allInteractions.push({
-              ...interaction,
-              category: categoryInfo.category,
-              originalCategory: categoryInfo.originalCategory
-            });
-          });
-        }
-      }
-
-      // Sort by timestamp (chronological order)
-      allInteractions.sort((a, b) => {
-        const timestampA = new Date(a.timestamp || 0);
-        const timestampB = new Date(b.timestamp || 0);
-        return timestampA - timestampB;
-      });
-
-      return allInteractions;
-    },
-
-    /**
-     * Get chronological interactions for backend
-     * 
-     * Returns both chronological array and categorized structure
-     * 
-     * Returns: Object with chronological and categorized interactions
-     */
-    getChronologicalForBackend() {
-      const chronological = this.getChronological();
-
-      return {
-        chronological: chronological,
-        categorized: sessionData.interactions
-      };
-    },
-
-    /**
-     * Deduplicate interactions
-     * 
-     * Removes duplicate interactions based on timestamp, category, and key fields
-     * 
-     * Logic:
-     * - Compares interactions by timestamp, category, and element identifier
-     * - Keeps first occurrence of duplicates
-     * - Updates total count after deduplication
-     */
-    deduplicate() {
-      if (!sessionData.interactions) return;
-
-      const seen = new Set();
-
-      for (const category of this.CATEGORIES) {
-        if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-          sessionData.interactions[category] = sessionData.interactions[category].filter(interaction => {
-            // Create unique key from timestamp, category, and element identifier
-            const elementId = interaction.elementId || interaction.target || interaction.selector || '';
-            const key = `${interaction.timestamp}_${category}_${elementId}`;
-
-            if (seen.has(key)) {
-              return false; // Duplicate, remove
-            }
-
-            seen.add(key);
-            return true; // Keep
-          });
-        }
-      }
-
-      // Update total count after deduplication
-      this.updateTotalCount();
-
-      // Update session storage
-      this.updateSessionStorage();
-    },
-
-    /**
-     * Get interactions by category
-     * 
-     * Returns all interactions for a specific category
-     * 
-     * Parameters: category - Interaction category name
-     * Returns: Array of interactions for that category
-     */
-    getByCategory(category) {
-      if (!sessionData.interactions) {
-        return [];
-      }
-
-      if (!this.CATEGORIES.includes(category)) {
-        return [];
-      }
-
-      return sessionData.interactions[category] || [];
-    },
-
-    /**
-     * Get total interactions count
-     * 
-     * Returns total number of interactions across all categories
-     */
-    getTotalCount() {
-      if (!sessionData.interactions) {
-        return 0;
-      }
-
-      return sessionData.interactions.totalInteractions || 0;
-    },
-
-    /**
-     * Clear all interactions
-     * 
-     * Resets interactions object to empty state
-     */
-    clear() {
-      this.initialize();
-      for (const category of this.CATEGORIES) {
-        sessionData.interactions[category] = [];
-      }
-      sessionData.interactions.totalInteractions = 0;
-      this.updateSessionStorage();
-    }
+    CATEGORIES: [],
+    initialize() {},
+    add() {},
+    updateTotalCount() {},
+    updateSessionStorage() {},
+    getChronological() { return []; },
+    getChronologicalForBackend() { return { chronological: [], categorized: {} }; },
+    deduplicate() {},
+    getByCategory() { return []; },
+    getTotalCount() { return 0; },
+    clear() {}
   };
 
   // ============================================================================
@@ -3914,6 +3602,8 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
       history.pushState = function(...args) {
         originalPushState.apply(history, args);
+        // Notify page_summary exit-type tracker that an SPA navigation occurred
+        try { window.dispatchEvent(new CustomEvent('cq:spa-navigation')); } catch (_) {}
         // Use requestAnimationFrame for better timing with React Router
         requestAnimationFrame(() => {
           self.track();
@@ -3922,6 +3612,8 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
       history.replaceState = function(...args) {
         originalReplaceState.apply(history, args);
+        // Notify page_summary exit-type tracker (replaceState = SPA redirect)
+        try { window.dispatchEvent(new CustomEvent('cq:spa-navigation')); } catch (_) {}
         // Use requestAnimationFrame for better timing with React Router
         requestAnimationFrame(() => {
           self.track();
@@ -3984,7 +3676,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       // Ensure arrays exist
       s.pageVisits = s.pageVisits || [];
       s.visited_pages = s.visited_pages || [];
-      s.interactions = s.interactions || { totalInteractions: 0 };
       
       // Normalize timestamps to ISO strings
       if (s.startTime && !(typeof s.startTime === 'string')) {
@@ -4039,171 +3730,8 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       // First normalize the shape
       sourceData = this.normalizeShape(sourceData);
       
-      // Get chronological interactions
-      const chronologicalInteractions = InteractionManager.getChronologicalForBackend();
-      
-      // Get page visits and session-level interactions
+      // Get page visits
       const pageVisits = sourceData.visited_pages || sourceData.pageVisits || sourceData.visitedPages || [];
-      const sessionInteractions = sourceData.interactions || {};
-      
-      // CRITICAL FIX: Distribute session-level interactions to appropriate pages based on path
-      const interactionTypes = [
-        'clicks', 'mediaInteractions', 'contextMenuEvents', 'windowEvents',
-        'formInteractions', 'scrollEvents', 'focusEvents', 'hoverEvents',
-        'formSubmissions', 'fieldChanges',
-        'keyboardEvents', 'copyPasteEvents', 'dragDropEvents',
-        'touchEvents', 'formAnalytics'
-        // Note: validationErrors, performanceEvents, errorEvents, networkEvents are no longer
-        // stored in session interactions — they are emitted as individual queryable auto events
-        // (form_validation_error, page_performance, js_error, network_error)
-      ];
-      
-      // Helper to normalize path for matching
-      const normalizePathForMatching = (path) => {
-        if (!path) return '/';
-        // Remove query params and hash
-        const cleanPath = path.split('?')[0].split('#')[0];
-        return cleanPath || '/';
-      };
-      
-      // Get session start time in milliseconds for alignment
-      const sessionStartTime = sourceData.start_time || sourceData.startTime;
-      const sessionStartMs = sessionStartTime 
-        ? (typeof sessionStartTime === 'string' ? new Date(sessionStartTime).getTime() : sessionStartTime)
-        : Date.now();
-      
-      // Distribute interactions to pages and fix mount/unmount times
-      // CRITICAL: Create copies to avoid mutating original objects
-      const pagesWithInteractions = pageVisits.map((pageVisit, index) => {
-        // Create a copy of the page visit to avoid mutating the original
-        const pageVisitCopy = { ...pageVisit };
-        const pagePath = normalizePathForMatching(pageVisitCopy.path || pageVisitCopy.url);
-        const isFirstPage = index === 0 || pageVisitCopy.isEntry === true;
-        
-        // CRITICAL FIX: If unmountTime is null, set it to next page's mountTime
-        if (!pageVisitCopy.unmountTime && index < pageVisits.length - 1) {
-          const nextPage = pageVisits[index + 1];
-          if (nextPage && nextPage.mountTime) {
-            pageVisitCopy.unmountTime = typeof nextPage.mountTime === 'number' 
-              ? nextPage.mountTime 
-              : new Date(nextPage.mountTime).getTime();
-            // Recalculate duration
-            if (pageVisitCopy.mountTime) {
-              const mountMs = typeof pageVisitCopy.mountTime === 'number'
-                ? pageVisitCopy.mountTime
-                : new Date(pageVisitCopy.mountTime).getTime();
-              pageVisitCopy.duration = Math.floor((pageVisitCopy.unmountTime - mountMs) / 1000);
-            }
-          }
-        }
-        
-        // If still no unmountTime and this is the last page, set to session endTime
-        if (!pageVisitCopy.unmountTime && index === pageVisits.length - 1) {
-          const endTime = sourceData.end_time || sourceData.endTime;
-          if (endTime) {
-            pageVisitCopy.unmountTime = typeof endTime === 'number'
-              ? endTime
-              : new Date(endTime).getTime();
-            // Recalculate duration
-            if (pageVisitCopy.mountTime) {
-              const mountMs = typeof pageVisitCopy.mountTime === 'number'
-                ? pageVisitCopy.mountTime
-                : new Date(pageVisitCopy.mountTime).getTime();
-              pageVisitCopy.duration = Math.floor((pageVisitCopy.unmountTime - mountMs) / 1000);
-            }
-          }
-        }
-        
-        // FIX: Align first page mountTime with session start_time (only in copy, not original)
-        if (isFirstPage && pageVisitCopy.mountTime) {
-          const mountTimeMs = typeof pageVisitCopy.mountTime === 'number' 
-            ? pageVisitCopy.mountTime 
-            : new Date(pageVisitCopy.mountTime).getTime();
-          
-          // If mountTime is more than 5 minutes off from session start, align it
-          const timeDiff = Math.abs(mountTimeMs - sessionStartMs);
-          if (timeDiff > 5 * 60 * 1000) { // More than 5 minutes difference
-            pageVisitCopy.mountTime = sessionStartMs;
-            // Recalculate duration if unmountTime exists
-            if (pageVisitCopy.unmountTime) {
-              const unmountTimeMs = typeof pageVisitCopy.unmountTime === 'number'
-                ? pageVisitCopy.unmountTime
-                : new Date(pageVisitCopy.unmountTime).getTime();
-              pageVisitCopy.duration = Math.floor((unmountTimeMs - sessionStartMs) / 1000);
-            }
-          }
-        }
-        
-        // Ensure mountTime and unmountTime are numbers (milliseconds) for consistency (in copy only)
-        if (pageVisitCopy.mountTime && typeof pageVisitCopy.mountTime !== 'number') {
-          pageVisitCopy.mountTime = new Date(pageVisitCopy.mountTime).getTime();
-        }
-        if (pageVisitCopy.unmountTime && typeof pageVisitCopy.unmountTime !== 'number') {
-          pageVisitCopy.unmountTime = new Date(pageVisitCopy.unmountTime).getTime();
-        }
-        
-        // Initialize interactions object for this page if it doesn't exist (in copy)
-        if (!pageVisitCopy.interactions) {
-          pageVisitCopy.interactions = {
-            totalInteractions: 0,
-            clicks: [],
-            mediaInteractions: [],
-            contextMenuEvents: [],
-            windowEvents: [],
-            formInteractions: [],
-            scrollEvents: [],
-            focusEvents: [],
-            hoverEvents: [],
-            formSubmissions: [],
-            fieldChanges: [],
-            validationErrors: [],
-            keyboardEvents: [],
-            copyPasteEvents: [],
-            dragDropEvents: [],
-            touchEvents: [],
-            performanceEvents: [],
-            errorEvents: [],
-            networkEvents: [],
-            formAnalytics: []
-          };
-        }
-        
-        // Distribute interactions from session-level to this page based on path matching (in copy)
-        interactionTypes.forEach(type => {
-          if (Array.isArray(sessionInteractions[type])) {
-            sessionInteractions[type].forEach(interaction => {
-              const interactionPath = normalizePathForMatching(interaction.path);
-              if (interactionPath === pagePath) {
-                // Add interaction to this page (avoid duplicates)
-                const exists = pageVisitCopy.interactions[type].some(existing => {
-                  // Check for duplicates based on timestamp and key properties
-                  if (existing.timestamp && interaction.timestamp) {
-                    return existing.timestamp === interaction.timestamp;
-                  }
-                  // For clicks, check element properties
-                  if (type === 'clicks' && existing.element && interaction.element) {
-                    return existing.element.id === interaction.element.id &&
-                           existing.element.tagName === interaction.element.tagName;
-                  }
-                  return false;
-                });
-                
-                if (!exists) {
-                  pageVisitCopy.interactions[type].push(interaction);
-                }
-              }
-            });
-          }
-        });
-        
-        // Calculate totalInteractions for this page (in copy)
-        const total = interactionTypes.reduce((sum, type) => {
-          return sum + (pageVisitCopy.interactions[type]?.length || 0);
-        }, 0);
-        pageVisitCopy.interactions.totalInteractions = total;
-        
-        return pageVisitCopy;
-      });
       
       // Create transformed object - PostgreSQL snake_case format only
       const transformed = {
@@ -4268,12 +3796,8 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         utm_content: sourceData.utm_content || sourceData.utmData?.content || null,
         utm_id: sourceData.utm_id || sourceData.utmData?.utm_id || null,
         
-        // JSONB fields - NOW WITH INTERACTIONS DISTRIBUTED TO PAGES
-        visited_pages: pagesWithInteractions,
-        interactions: {
-          ...sessionInteractions,
-          chronological: chronologicalInteractions.chronological || []
-        },
+        // JSONB fields
+        visited_pages: pageVisits,
 
         // Active tab time in ms (tab foreground time only, for active_time_seconds in DB)
         active_time_ms: sourceData.active_time_ms || null
@@ -4941,12 +4465,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
             if (hoveredElements.has(elementId)) {
               hoveredElements.delete(elementId);
               
-              // Update hover duration in the interaction
-              const interactions = InteractionManager.getByCategory('hoverEvents');
-              const hoverEvent = interactions.find(h => h.elementId === elementId);
-              if (hoverEvent) {
-                hoverEvent.hoverDuration = Date.now() - new Date(hoverEvent.timestamp).getTime();
-              }
             }
           }
         });
@@ -5288,12 +4806,33 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
                 : null;
             } catch (e) {}
 
+            // Collect top-3 slowest resources to pinpoint what is causing slow LCP/FCP.
+            // Each entry: { name (URL), initiator_type, duration_ms, transfer_size_kb }
+            // Only includes same-origin resources or entries where the timing is exposed
+            // (cross-origin resources without Timing-Allow-Origin return duration = 0
+            //  and are excluded as they carry no actionable signal).
+            let slowestResources = [];
+            try {
+              const resources = performance.getEntriesByType('resource');
+              slowestResources = resources
+                .filter(r => r.duration > 0) // exclude zero-duration cross-origin entries
+                .sort((a, b) => b.duration - a.duration)
+                .slice(0, 3)
+                .map(r => ({
+                  name:             r.name.split('?')[0].slice(-120), // trim query string + cap length
+                  initiator_type:   r.initiatorType || 'other',       // script, css, img, fetch, xmlhttprequest…
+                  duration_ms:      Math.round(r.duration),
+                  transfer_size_kb: r.transferSize ? Math.round(r.transferSize / 1024) : null
+                }));
+            } catch (_) {}
+
             EventsManager.trackAutoEvent('page_performance', {
-              lcp: vitals.lcp,
-              cls: vitals.cls,
-              inp: vitals.inp,
-              fcp: vitals.fcp,
-              ttfb: vitals.ttfb
+              lcp:               vitals.lcp,
+              cls:               vitals.cls,
+              inp:               vitals.inp,
+              fcp:               vitals.fcp,
+              ttfb:              vitals.ttfb,
+              slowest_resources: slowestResources  // [] when none available
             });
           }, 1500);
         });
@@ -5303,54 +4842,108 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
     /**
      * ErrorTracker - Tracks JavaScript errors
-     * Emits as queryable auto events (js_error) instead of session-level JSONB
+     * Emits as queryable auto events (js_error) instead of session-level JSONB.
+     *
+     * Improvements over original:
+     *  - error_class: extracts the constructor name (TypeError, ReferenceError, etc.)
+     *    so the AI can categorise errors without parsing message strings.
+     *  - Session-level deduplication: same error (same message + source + line)
+     *    fires at most once per 10 s to prevent event floods from looping errors.
+     *  - last_event_name: name of the most-recently tracked auto event, giving a
+     *    lightweight "what was the user doing just before the crash" signal.
      */
     startErrorTracking() {
       try {
+        // Deduplication: hash → last-fired timestamp (ms)
+        const recentErrors = new Map();
+        const ERROR_DEDUPE_MS = 10000; // suppress repeats within 10 s
+
+        // Lightweight "preceding action" tracker — updated by trackAutoEvent callers
+        // via a module-level variable so it's always current.
+        if (!EventsManager._lastAutoEventName) {
+          EventsManager._lastAutoEventName = '';
+        }
+
+        const dedupeKey = (msg, src, line) =>
+          `${msg}|${src}|${line}`.slice(0, 200);
+
+        const shouldSuppress = (key) => {
+          const last = recentErrors.get(key);
+          if (!last) return false;
+          return (Date.now() - last) < ERROR_DEDUPE_MS;
+        };
+
+        const markSeen = (key) => recentErrors.set(key, Date.now());
+
+        // Extract class name from the error object's constructor, e.g. "TypeError"
+        const getErrorClass = (errObj) => {
+          if (!errObj) return 'Error';
+          try { return errObj.constructor?.name || 'Error'; } catch (_) { return 'Error'; }
+        };
+
         window.addEventListener('error', (event) => {
+          const msg  = event.message || '';
+          const src  = event.filename || '';
+          const line = event.lineno  || 0;
+          const key  = dedupeKey(msg, src, line);
+          if (shouldSuppress(key)) return;
+          markSeen(key);
+
           EventsManager.trackAutoEvent('js_error', {
-            error_type: 'javascript_error',
-            message: event.message || '',
-            source: event.filename || '',
-            line: event.lineno || 0,
-            column: event.colno || 0,
-            stack: event.error?.stack || ''
+            error_type:       'javascript_error',
+            error_class:      getErrorClass(event.error),
+            message:          msg,
+            source:           src,
+            line:             line,
+            column:           event.colno || 0,
+            stack:            event.error?.stack || '',
+            last_event_name:  EventsManager._lastAutoEventName || ''
           });
         });
 
-        // Track unhandled promise rejections
+        // Unhandled promise rejections (fetch failures that aren't caught, async throws, etc.)
         window.addEventListener('unhandledrejection', (event) => {
+          const msg  = event.reason?.message || String(event.reason || 'Unknown error');
+          const key  = dedupeKey(msg, '', 0);
+          if (shouldSuppress(key)) return;
+          markSeen(key);
+
           EventsManager.trackAutoEvent('js_error', {
-            error_type: 'unhandled_promise_rejection',
-            message: event.reason?.message || String(event.reason || 'Unknown error'),
-            stack: event.reason?.stack || String(event.reason || '')
+            error_type:      'unhandled_promise_rejection',
+            error_class:     getErrorClass(event.reason),
+            message:         msg,
+            stack:           event.reason?.stack || String(event.reason || ''),
+            last_event_name: EventsManager._lastAutoEventName || ''
           });
         });
       } catch (error) {
-        }
+      }
     },
 
     /**
-     * NetworkTracker - Tracks network errors (XHR only)
+     * NetworkTracker - Tracks network errors (XHR + fetch)
      *
-     * NOTE:
-     * We intentionally do NOT wrap window.fetch here, to avoid confusing
-     * browser DevTools attribution for third‑party requests. All SDK
-     * fetch-based calls to the SDK API backend (sdkapi.cryptique.io) are already
-     * error-handled inside APIClient.send(), so fetch wrapping is redundant.
+     * XHR: only wraps SDK calls to sdkapi.cryptique.io (unchanged behaviour).
+     *
+     * fetch: wraps window.fetch to track HTTP ≥ 400 responses and network
+     * failures for same-origin requests made by the host application.
+     * Third-party (cross-origin) fetches are passed through untouched to
+     * minimise DevTools attribution noise. The SDK's own fetch calls via
+     * APIClient.send() are already error-handled and are excluded by the
+     * same-origin guard (they go to sdkapi.cryptique.io, not the app origin).
      */
     startNetworkTracking() {
       try {
-        // Track XMLHttpRequest errors - only intercept calls to our own backend
+        // ── XHR: unchanged — only track SDK backend calls ──────────────────
         const originalXHROpen = XMLHttpRequest.prototype.open;
         const originalXHRSend = XMLHttpRequest.prototype.send;
-        
+
         XMLHttpRequest.prototype.open = function(method, url, ...args) {
           this._cryptiqueMethod = method;
           this._cryptiqueUrl = url;
           return originalXHROpen.apply(this, [method, url, ...args]);
         };
-        
+
         XMLHttpRequest.prototype.send = function(...args) {
           const startTime = Date.now();
           const xhr = this;
@@ -5359,7 +4952,7 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
           if (!xhr._cryptiqueUrl || !xhr._cryptiqueUrl.includes('sdkapi.cryptique.io')) {
             return originalXHRSend.apply(this, args);
           }
-          
+
           xhr.addEventListener('load', function() {
             if (xhr.status >= 400) {
               EventsManager.trackAutoEvent('network_error', {
@@ -5381,11 +4974,77 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
               duration_ms: Date.now() - startTime
             });
           });
-          
+
           return originalXHRSend.apply(this, args);
         };
-      } catch (error) {
+
+        // ── fetch: track same-origin HTTP errors from the host application ──
+        // We intercept only same-origin (or explicitly relative) URLs so that
+        // third-party CDN / analytics / auth calls are never touched.
+        const originalFetch = window.fetch;
+        if (typeof originalFetch === 'function') {
+          window.fetch = function(input, init) {
+            const startTime = Date.now();
+
+            // Resolve the URL string regardless of whether input is a string,
+            // URL object, or Request object.
+            let urlStr = '';
+            try {
+              urlStr = (input instanceof Request ? input.url : String(input)) || '';
+            } catch (_) {}
+
+            // Determine if same-origin (relative URLs are always same-origin)
+            let isSameOrigin = false;
+            try {
+              if (urlStr.startsWith('/') || urlStr.startsWith('./') || urlStr.startsWith('../')) {
+                isSameOrigin = true;
+              } else {
+                const parsed = new URL(urlStr, window.location.href);
+                isSameOrigin = parsed.origin === window.location.origin;
+              }
+            } catch (_) {}
+
+            // Skip SDK's own backend calls — already handled by APIClient.send()
+            if (urlStr.includes('sdkapi.cryptique.io')) {
+              return originalFetch.apply(this, arguments);
+            }
+
+            // Pass cross-origin calls through untouched
+            if (!isSameOrigin) {
+              return originalFetch.apply(this, arguments);
+            }
+
+            const method = (init?.method || (input instanceof Request ? input.method : 'GET') || 'GET').toUpperCase();
+
+            return originalFetch.apply(this, arguments).then(
+              (response) => {
+                if (response.status >= 400) {
+                  EventsManager.trackAutoEvent('network_error', {
+                    url:          urlStr,
+                    method:       method,
+                    status:       response.status,
+                    status_text:  `HTTP ${response.status} Error`,
+                    duration_ms:  Date.now() - startTime
+                  });
+                }
+                return response;
+              },
+              (err) => {
+                // Network-level failure (offline, DNS, CORS preflight, etc.)
+                EventsManager.trackAutoEvent('network_error', {
+                  url:         urlStr,
+                  method:      method,
+                  status:      0,
+                  status_text: 'Fetch Network Error',
+                  duration_ms: Date.now() - startTime
+                });
+                throw err; // re-throw so the calling code still gets the error
+              }
+            );
+          };
         }
+      } catch (error) {
+      }
     },
 
     /**
@@ -5658,8 +5317,54 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         let clsScore                  = 0;
         let longTasksCount            = 0;
         let maxLongTaskMs             = 0;
+        let longTaskTimestamps        = []; // [{start_ms, duration_ms}] capped at 20
         let inpMs                     = 0;
 
+        // ── Exit type detection ─────────────────────────────────────────────
+        // Classifies HOW the user left this page so the AI can distinguish
+        // explicit rejection (back-button) from fatigue (tab-close) from
+        // internal navigation (SPA route change or page refresh).
+        //
+        // Values:
+        //   'back_forward'    – browser back/forward button (popstate)
+        //   'spa_navigation'  – SPA pushState / replaceState route change
+        //   'reload'          – page refresh (F5 / Ctrl+R / location.reload)
+        //   'tab_close'       – tab or window closed (beforeunload, no subsequent nav)
+        //   'unknown'         – couldn't be determined (visibilitychange, iOS Safari, etc.)
+        let pageExitType = 'unknown';
+
+        window.addEventListener('popstate', () => {
+          pageExitType = 'back_forward';
+        }, { once: true });
+
+        // Intercept SPA navigation — hook into the already-overridden pushState /
+        // replaceState (the overrides were applied in Section 11: SessionTracker).
+        // We listen to the 'cq:spa-navigation' custom event that we dispatch below,
+        // rather than overriding pushState a second time.
+        // Detect by watching for our own navigation event (fired by SessionTracker).
+        window.addEventListener('cq:spa-navigation', () => {
+          if (pageExitType === 'unknown') pageExitType = 'spa_navigation';
+        }, { once: true });
+
+        // Detect reload via PerformanceNavigationTiming.type === 'reload'
+        try {
+          const navEntry = performance.getEntriesByType('navigation')[0];
+          if (navEntry && navEntry.type === 'reload') {
+            // The CURRENT page was reached by reload; if user reloads again
+            // we'll see another 'reload' on the next load — set a provisional flag.
+            pageExitType = 'reload_arrived'; // overridden by popstate/spa if applicable
+          }
+        } catch (_) {}
+
+        window.addEventListener('beforeunload', () => {
+          // beforeunload fires for tab-close AND for hard navigations (link clicks,
+          // address-bar entry). SPA navigations do NOT fire it. popstate fires
+          // before pagehide for back/forward so the flag is already set.
+          if (pageExitType === 'unknown' || pageExitType === 'reload_arrived') {
+            pageExitType = 'tab_close';
+          }
+        });
+
         const pageLoadTime  = Date.now();
         let lastSigScrollY  = window.scrollY;
         let lastSigDir      = 0; // 1=down, -1=up
@@ -5691,6 +5396,16 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
             for (const e of list.getEntries()) {
               longTasksCount++;
               if (e.duration > maxLongTaskMs) maxLongTaskMs = Math.round(e.duration);
+              // Record when each long task started (ms since page load, same reference
+              // frame as first_interaction_ms) so the AI can correlate main-thread
+              // blocking with the moment a user first tried to interact.
+              // Cap at 20 — pathological pages sample the earliest 20 tasks.
+              if (longTaskTimestamps.length < 20) {
+                longTaskTimestamps.push({
+                  start_ms:    Math.round(e.startTime),
+                  duration_ms: Math.round(e.duration)
+                });
+              }
             }
           }).observe({ type: 'longtask', buffered: true });
         } catch (_) {}
@@ -5931,6 +5646,11 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
               .sort((a, b) => b.dwell_ms - a.dwell_ms)
               .slice(0, 20);
 
+            // Finalise exit_type: if it's still the provisional reload_arrived value
+            // (user reloaded this page and didn't navigate away via back/spa), keep it
+            // as 'reload' since the beforeunload didn't fire (e.g. visibilitychange path).
+            const finalExitType = pageExitType === 'reload_arrived' ? 'reload' : pageExitType;
+
             EventsManager.trackAutoEvent('page_summary', {
               scroll_reversals:              scrollReversals,
               scroll_reversal_depths:        scrollReversalDepths,
@@ -5947,7 +5667,9 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
               cls_score:                     clsScore,
               long_tasks_count:              longTasksCount,
               max_long_task_ms:              maxLongTaskMs,
+              long_task_timestamps:          longTaskTimestamps,
               inp_ms:                        inpMs,
+              exit_type:                     finalExitType,
               document_height: document.documentElement.scrollHeight || document.body.scrollHeight || 0,
               document_width:  document.documentElement.scrollWidth  || document.body.scrollWidth  || 0,
               viewport_width:  window.innerWidth,
@@ -6061,9 +5783,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         // Initialize session data structure
         SessionDataManager.initialize(sessionId, userId);
         
-        // Initialize interactions
-        InteractionManager.initialize();
-        
         // Initialize page visits
         PageVisitManager.initialize();
       } catch (error) {
@@ -6206,15 +5925,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
                 sessionData.pagesViewed = sessionData.visited_pages.length;
               }
 
-              // Sync interactions
-              if (storedSession.sessionData.interactions) {
-                const storedInteractions = storedSession.sessionData.interactions;
-                if (storedInteractions.totalInteractions > 
-                    (sessionData.interactions?.totalInteractions || 0)) {
-                  // Update interactions from storage
-                  sessionData.interactions = storedInteractions;
-                }
-              }
             }
 
             // Update endTime
@@ -6277,9 +5987,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
                 }));
                 sessionData.pagesViewed = sessionData.visited_pages.length;
               }
-              if (storedSession.sessionData.interactions) {
-                sessionData.interactions = storedSession.sessionData.interactions;
-              }
             }
 
             // Track browser close (last page unmount)
@@ -6654,6 +6361,13 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
      */
     async trackAutoEvent(eventName, autoEventData = {}, elementData = {}) {
       try {
+        // Keep a running record of the last auto-event name so that js_error
+        // events can include a "last_event_name" field for context.
+        // Skip error-category events themselves to avoid circular noise.
+        if (eventName && eventName !== 'js_error' && eventName !== 'network_error') {
+          EventsManager._lastAutoEventName = eventName;
+        }
+
         // Check if auto events should be tracked (silently skip if disabled)
         if (!shouldTrackAutoEvents()) {
           return; // Silently skip - don't log to avoid console spam
@@ -7332,8 +7046,23 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       let clickCount = 0;
       let lastClickTime = 0;
       let lastClickElement = null;
+      let rageStartTime = 0;   // Timestamp of the first click in the current rage sequence
+      let rageTimer = null;    // Debounce timer — fires ONE rage_click after sequence ends
       const pendingDeadClicks = new Map(); // Track clicks that might be dead clicks
 
+      // MutationObserver counter — incremented on ANY DOM change.
+      // Dead-click detection compares the count at click-time vs 800 ms later:
+      // if nothing changed (URL stable + zero new mutations) it's a true dead click.
+      // This prevents false positives in SPAs where interactions update the DOM
+      // without changing the URL (modals, dropdowns, cart updates, tab panels, etc.).
+      let domMutationCount = 0;
+      try {
+        new MutationObserver(() => { domMutationCount++; })
+          .observe(document.documentElement, {
+            childList: true, subtree: true, attributes: true, characterData: false
+          });
+      } catch (_) {}
+
       // Helper function to check if element is interactive
       const isInteractiveElement = (el) => {
         if (!el) return false;
@@ -7423,31 +7152,60 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
           elementData.image_height = element.naturalHeight || null;
         }
 
-        // Detect rage clicks (multiple clicks on same element quickly)
+        // Detect rage clicks — fire exactly ONE event per sequence when the burst ends.
+        // A "sequence" is N rapid clicks on the same element within 1 s of each other.
+        // We debounce 800 ms after the last click so the event carries the FINAL count
+        // and the total time-span from first to last click (not just the last interval).
         if (element === lastClickElement && now - lastClickTime < 1000) {
           clickCount++;
+
           if (clickCount >= 3) {
-            const scrollX = window.scrollX != null ? window.scrollX : window.pageXOffset;
-            const scrollY = window.scrollY != null ? window.scrollY : window.pageYOffset;
-            const docHeight = Math.min(Math.max(document.body.scrollHeight, document.documentElement.scrollHeight), 25000);
-            const docWidth = Math.min(Math.max(document.body.scrollWidth, document.documentElement.scrollWidth), 25000);
-            EventsManager.trackAutoEvent('rage_click', {
-              click_coordinates: { x: event.clientX, y: event.clientY },
-              page_x: event.pageX,
-              page_y: event.pageY,
-              scroll_x: scrollX,
-              scroll_y: scrollY,
-              document_height: docHeight,
-              document_width: docWidth,
-              click_count: clickCount,
-              time_span: now - lastClickTime,
-              element_area: element.offsetWidth * element.offsetHeight,
-              element_category: elementCategory
-            }, elementData).catch(err => {
-              });
+            // Cancel any previously scheduled fire — sequence is still ongoing
+            if (rageTimer) { clearTimeout(rageTimer); rageTimer = null; }
+
+            // Snapshot mutable values at the time of THIS click
+            const snapScrollX   = window.scrollX != null ? window.scrollX : window.pageXOffset;
+            const snapScrollY   = window.scrollY != null ? window.scrollY : window.pageYOffset;
+            const snapDocHeight = Math.min(Math.max(document.body.scrollHeight, document.documentElement.scrollHeight), 25000);
+            const snapDocWidth  = Math.min(Math.max(document.body.scrollWidth,  document.documentElement.scrollWidth),  25000);
+            const snapClientX   = event.clientX;
+            const snapClientY   = event.clientY;
+            const snapPageX     = event.pageX;
+            const snapPageY     = event.pageY;
+            const snapElemData  = Object.assign({}, elementData);
+            const snapCategory  = elementCategory;
+            const snapArea      = element.offsetWidth * element.offsetHeight;
+            const snapAriaLabel = element.getAttribute('aria-label') || null;
+            const snapStartTime = rageStartTime;
+            const snapNow       = now;
+
+            // Fire after 800 ms of inactivity — reads the FINAL clickCount from closure
+            rageTimer = setTimeout(() => {
+              rageTimer = null;
+              EventsManager.trackAutoEvent('rage_click', {
+                click_coordinates: { x: snapClientX, y: snapClientY },
+                page_x:            snapPageX,
+                page_y:            snapPageY,
+                scroll_x:          snapScrollX,
+                scroll_y:          snapScrollY,
+                document_height:   snapDocHeight,
+                document_width:    snapDocWidth,
+                click_count:       clickCount,          // final count for the whole sequence
+                time_span:         snapNow - snapStartTime, // first→last click duration
+                element_area:      snapArea,
+                element_category:  snapCategory,
+                aria_label:        snapAriaLabel
+              }, snapElemData).catch(() => {});
+              // Reset sequence state after the event is dispatched
+              clickCount = 0;
+              lastClickElement = null;
+            }, 800);
           }
         } else {
-          clickCount = 1;
+          // New element or gap > 1 s — start a fresh sequence
+          if (rageTimer) { clearTimeout(rageTimer); rageTimer = null; }
+          clickCount    = 1;
+          rageStartTime = now;
         }
 
         // Check if this might be a dead click (non-interactive element)
@@ -7471,6 +7229,7 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
             elementCategory,
             timestamp: now,
             url: window.location.href,
+            snapshotMutationCount: domMutationCount, // DOM state at click time
             clickX,
             clickY,
             page_x: event.pageX,
@@ -7481,13 +7240,17 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
             document_width: docWidth
           });
           
-          // Check after 1 second if navigation occurred or if it's still a dead click
+          // Check after 800 ms: if URL unchanged AND DOM unchanged → true dead click.
+          // Using 800 ms (down from 1 s) tightens the window while still allowing
+          // async renders (React setState, animations) to complete before we decide.
           setTimeout(() => {
             checkNavigation();
-            
+
             const pendingClick = pendingDeadClicks.get(clickId);
-            if (pendingClick && window.location.href === pendingClick.url) {
-              // No navigation occurred, this is a dead click
+            if (pendingClick &&
+                window.location.href === pendingClick.url &&
+                domMutationCount === pendingClick.snapshotMutationCount) {
+              // No URL change AND no DOM mutations → confirmed dead click
               pendingDeadClicks.delete(clickId);
               
               EventsManager.trackAutoEvent('dead_click', {
@@ -7507,10 +7270,10 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
                 console.error('❌ [AutoEvents] Failed to track dead_click:', err);
               });
             } else if (pendingClick) {
-              // Navigation occurred, not a dead click
+              // URL changed or DOM mutated — interaction was real, not a dead click
               pendingDeadClicks.delete(clickId);
             }
-          }, 1000);
+          }, 800);
         }
 
         // Track regular click with enhanced data (viewport + page-relative for heatmaps)
@@ -8406,10 +8169,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       return sessionData;
     },
     
-    // Interaction Functions
-    getChronologicalInteractions: InteractionManager.getChronological.bind(InteractionManager),
-    sortInteractionsChronologically: InteractionManager.getChronological.bind(InteractionManager),
-    
     // Auto Events Configuration
     enableAutoEvents: function() {
       CONFIG.AUTO_EVENTS.enabled = true;