cryptique-sdk 1.2.19 → 1.2.21

package/lib/umd/index.js

@@ -96,8 +96,8 @@
 
       // 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
       },
 
@@ -1143,7 +1143,6 @@
       isFirstPage: true,
       
       // JSONB fields
-      interactions: {},
       visited_pages: [],
       
       // Also stored in locationData object for structured access (backward compatibility)
@@ -2088,7 +2087,6 @@
         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
@@ -2153,8 +2151,7 @@
           // 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);
@@ -3198,333 +3195,24 @@
       }
     };
 
-    // ============================================================================
-    // 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() {}
     };
 
     // ============================================================================
@@ -3918,6 +3606,8 @@
 
         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();
@@ -3926,6 +3616,8 @@
 
         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();
@@ -3988,7 +3680,6 @@
         // 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')) {
@@ -4043,171 +3734,8 @@
         // 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 = {
@@ -4272,12 +3800,8 @@
           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
@@ -4945,12 +4469,6 @@
               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();
-                }
               }
             }
           });
@@ -5292,12 +4810,33 @@
                   : 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);
           });
@@ -5307,54 +4846,108 @@
 
       /**
        * 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;
@@ -5363,7 +4956,7 @@
             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', {
@@ -5385,11 +4978,77 @@
                 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) {
+        }
       },
 
       /**
@@ -5662,8 +5321,54 @@
           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
@@ -5695,6 +5400,16 @@
               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 (_) {}
@@ -5935,6 +5650,11 @@
                 .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,
@@ -5951,7 +5671,9 @@
                 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,
@@ -6065,9 +5787,6 @@
           // Initialize session data structure
           SessionDataManager.initialize(sessionId, userId);
           
-          // Initialize interactions
-          InteractionManager.initialize();
-          
           // Initialize page visits
           PageVisitManager.initialize();
         } catch (error) {
@@ -6210,15 +5929,6 @@
                   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
@@ -6281,9 +5991,6 @@
                   }));
                   sessionData.pagesViewed = sessionData.visited_pages.length;
                 }
-                if (storedSession.sessionData.interactions) {
-                  sessionData.interactions = storedSession.sessionData.interactions;
-                }
               }
 
               // Track browser close (last page unmount)
@@ -6658,6 +6365,13 @@
        */
       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
@@ -7336,8 +7050,23 @@
         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;
@@ -7427,31 +7156,60 @@
             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)
@@ -7475,6 +7233,7 @@
               elementCategory,
               timestamp: now,
               url: window.location.href,
+              snapshotMutationCount: domMutationCount, // DOM state at click time
               clickX,
               clickY,
               page_x: event.pageX,
@@ -7485,13 +7244,17 @@
               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', {
@@ -7511,10 +7274,10 @@
                   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)
@@ -8410,10 +8173,6 @@
         return sessionData;
       },
       
-      // Interaction Functions
-      getChronologicalInteractions: InteractionManager.getChronological.bind(InteractionManager),
-      sortInteractionsChronologically: InteractionManager.getChronological.bind(InteractionManager),
-      
       // Auto Events Configuration
       enableAutoEvents: function() {
         CONFIG.AUTO_EVENTS.enabled = true;