mixpanel-browser 2.78.0 → 2.80.0

package/dist/mixpanel.umd.js

@@ -31,7 +31,7 @@
 
     var Config = {
         DEBUG: false,
-        LIB_VERSION: '2.78.0'
+        LIB_VERSION: '2.80.0'
     };
 
     // Window global names for async modules
@@ -19129,6 +19129,7 @@
     var console_with_prefix = function(prefix) {
         return {
             log: log_func_with_prefix(console$1.log, prefix),
+            warn: log_func_with_prefix(console$1.warn, prefix),
             error: log_func_with_prefix(console$1.error, prefix),
             critical: log_func_with_prefix(console$1.critical, prefix)
         };
@@ -20075,7 +20076,8 @@
         if (_localStorageSupported !== null && !forceCheck) {
             return _localStorageSupported;
         }
-        return _localStorageSupported = _testStorageSupported(storage || win.localStorage);
+
+        return _localStorageSupported = _testStorageSupported(storage);
     };
 
     var _sessionStorageSupported = null;
@@ -20083,7 +20085,8 @@
         if (_sessionStorageSupported !== null && !forceCheck) {
             return _sessionStorageSupported;
         }
-        return _sessionStorageSupported = _testStorageSupported(storage || win.sessionStorage);
+
+        return _sessionStorageSupported = _testStorageSupported(storage);
     };
 
     function _storageWrapper(storage, name, is_supported_fn) {
@@ -20133,17 +20136,26 @@
         };
     }
 
-    // Safari errors out accessing localStorage/sessionStorage when cookies are disabled,
-    // so create dummy storage wrappers that silently fail as a fallback.
-    var windowLocalStorage = null, windowSessionStorage = null;
-    try {
-        windowLocalStorage = win.localStorage;
-        windowSessionStorage = win.sessionStorage;
-        // eslint-disable-next-line no-empty
-    } catch (_err) {}
+    // Safari and other browsers may error out accessing localStorage/sessionStorage
+    // when cookies are disabled, so wrap access in a try-catch.
+    var getLocalStorage = function() {
+        try {
+            return win.localStorage; // eslint-disable-line no-restricted-properties
+        } catch (_err) {
+            return null;
+        }
+    };
+
+    var getSessionStorage = function() {
+        try {
+            return win.sessionStorage; // eslint-disable-line no-restricted-properties
+        } catch (_err) {
+            return null;
+        }
+    };
 
-    _.localStorage = _storageWrapper(windowLocalStorage, 'localStorage', localStorageSupported);
-    _.sessionStorage = _storageWrapper(windowSessionStorage, 'sessionStorage', sessionStorageSupported);
+    _.localStorage = _storageWrapper(getLocalStorage(), 'localStorage', localStorageSupported);
+    _.sessionStorage = _storageWrapper(getSessionStorage(), 'sessionStorage', sessionStorageSupported);
 
     _.register_event = (function() {
         // written by Dean Edwards, 2005
@@ -20812,29 +20824,26 @@
     _['toArray']                = _.toArray;
     _['NPO']                    = NpoPromise;
 
-    var MIXPANEL_DB_NAME = 'mixpanelBrowserDb';
-
-    var RECORDING_EVENTS_STORE_NAME = 'mixpanelRecordingEvents';
-    var RECORDING_REGISTRY_STORE_NAME = 'mixpanelRecordingRegistry';
-
-    // note: increment the version number when adding new object stores
-    var DB_VERSION = 1;
-    var OBJECT_STORES = [RECORDING_EVENTS_STORE_NAME, RECORDING_REGISTRY_STORE_NAME];
-
     /**
      * @type {import('./wrapper').StorageWrapper}
      */
-    var IDBStorageWrapper = function (storeName) {
+    var IDBStorageWrapper = function (dbName, storeName, versionData) {
+        this.dbName = dbName;
+        this.storeName = storeName;
+        this.version = versionData.version;
+        this.storeNamesInDb = versionData.storeNames;
         /**
          * @type {Promise<IDBDatabase>|null}
          */
         this.dbPromise = null;
-        this.storeName = storeName;
     };
 
     IDBStorageWrapper.prototype._openDb = function () {
+        var dbName = this.dbName;
+        var version = this.version;
+        var storeNamesInDb = this.storeNamesInDb;
         return new PromisePolyfill(function (resolve, reject) {
-            var openRequest = win.indexedDB.open(MIXPANEL_DB_NAME, DB_VERSION);
+            var openRequest = win.indexedDB.open(dbName, version);
             openRequest['onerror'] = function () {
                 reject(openRequest.error);
             };
@@ -20846,8 +20855,10 @@
             openRequest['onupgradeneeded'] = function (ev) {
                 var db = ev.target.result;
 
-                OBJECT_STORES.forEach(function (storeName) {
-                    db.createObjectStore(storeName);
+                storeNamesInDb.forEach(function (storeName) {
+                    if (!db.objectStoreNames.contains(storeName)) {
+                        db.createObjectStore(storeName);
+                    }
                 });
             };
         });
@@ -20939,6 +20950,16 @@
         });
     };
 
+    var MIXPANEL_BROWSER_DB_NAME = 'mixpanelBrowserDb';
+    var RECORDING_EVENTS_STORE_NAME = 'mixpanelRecordingEvents';
+    var RECORDING_REGISTRY_STORE_NAME = 'mixpanelRecordingRegistry';
+
+    // Keeping these two properties closeby, as adding additional stores to a DB in IndexedDB requires a version increment
+    var RECORDER_VERSION_DATA = {
+        version: 1,
+        storeNames: [RECORDING_EVENTS_STORE_NAME, RECORDING_REGISTRY_STORE_NAME]
+    };
+
     /**
      * GDPR utils
      *
@@ -21239,7 +21260,7 @@
         };
     }
 
-    var logger$8 = console_with_prefix('lock');
+    var logger$9 = console_with_prefix('lock');
 
     /**
      * SharedLock: a mutex built on HTML5 localStorage, to ensure that only one browser
@@ -21265,7 +21286,7 @@
         options = options || {};
 
         this.storageKey = key;
-        this.storage = options.storage || win.localStorage;
+        this.storage = options.storage || getLocalStorage();
         this.pollIntervalMS = options.pollIntervalMS || 100;
         this.timeoutMS = options.timeoutMS || 2000;
 
@@ -21291,7 +21312,7 @@
 
             var delay = function(cb) {
                 if (new Date().getTime() - startTime > timeoutMS) {
-                    logger$8.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
+                    logger$9.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
                     storage.removeItem(keyZ);
                     storage.removeItem(keyY);
                     loop();
@@ -21393,10 +21414,13 @@
      * @type {import('./wrapper').StorageWrapper}
      */
     var LocalStorageWrapper = function (storageOverride) {
-        this.storage = storageOverride || win.localStorage;
+        this.storage = storageOverride || getLocalStorage();
     };
 
     LocalStorageWrapper.prototype.init = function () {
+        if (!this.storage) {
+            return PromisePolyfill.reject(new Error('localStorage is not available'));
+        }
         return PromisePolyfill.resolve();
     };
 
@@ -21438,7 +21462,7 @@
         }, this));
     };
 
-    var logger$7 = console_with_prefix('batch');
+    var logger$8 = console_with_prefix('batch');
 
     /**
      * RequestQueue: queue for batching API requests with localStorage backup for retries.
@@ -21463,11 +21487,11 @@
         if (this.usePersistence) {
             this.queueStorage = options.queueStorage || new LocalStorageWrapper();
             this.lock = new SharedLock(storageKey, {
-                storage: options.sharedLockStorage || win.localStorage,
+                storage: options.sharedLockStorage,
                 timeoutMS: options.sharedLockTimeoutMS,
             });
         }
-        this.reportError = options.errorReporter || _.bind(logger$7.error, logger$7);
+        this.reportError = options.errorReporter || _.bind(logger$8.error, logger$8);
 
         this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios
 
@@ -21800,7 +21824,7 @@
     // maximum interval between request retries after exponential backoff
     var MAX_RETRY_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
 
-    var logger$6 = console_with_prefix('batch');
+    var logger$7 = console_with_prefix('batch');
 
     /**
      * RequestBatcher: manages the queueing, flushing, retry etc of requests of one
@@ -21928,7 +21952,7 @@
      */
     RequestBatcher.prototype.flush = function(options) {
         if (this.requestInProgress) {
-            logger$6.log('Flush: Request already in progress');
+            logger$7.log('Flush: Request already in progress');
             return PromisePolyfill.resolve();
         }
 
@@ -22105,7 +22129,7 @@
                 if (options.unloading) {
                     requestOptions.transport = 'sendBeacon';
                 }
-                logger$6.log('MIXPANEL REQUEST:', dataForRequest);
+                logger$7.log('MIXPANEL REQUEST:', dataForRequest);
                 return this.sendRequestPromise(dataForRequest, requestOptions).then(batchSendCallback);
             }, this))
             .catch(_.bind(function(err) {
@@ -22118,7 +22142,7 @@
      * Log error to global logger and optional user-defined logger.
      */
     RequestBatcher.prototype.reportError = function(msg, err) {
-        logger$6.error.apply(logger$6.error, arguments);
+        logger$7.error.apply(logger$7.error, arguments);
         if (this.errorReporter) {
             try {
                 if (!(err instanceof Error)) {
@@ -22126,7 +22150,7 @@
                 }
                 this.errorReporter(msg, err);
             } catch(err) {
-                logger$6.error(err);
+                logger$7.error(err);
             }
         }
     };
@@ -22271,7 +22295,7 @@
 
     var MAX_DEPTH = 5;
 
-    var logger$5 = console_with_prefix('autocapture');
+    var logger$6 = console_with_prefix('autocapture');
 
 
     function getClasses(el) {
@@ -22535,7 +22559,7 @@
                     return false;
                 }
             } catch (err) {
-                logger$5.critical('Error while checking element in allowElementCallback', err);
+                logger$6.critical('Error while checking element in allowElementCallback', err);
                 return false;
             }
         }
@@ -22552,7 +22576,7 @@
                     return true;
                 }
             } catch (err) {
-                logger$5.critical('Error while checking selector: ' + sel, err);
+                logger$6.critical('Error while checking selector: ' + sel, err);
             }
         }
         return false;
@@ -22567,7 +22591,7 @@
                     return true;
                 }
             } catch (err) {
-                logger$5.critical('Error while checking element in blockElementCallback', err);
+                logger$6.critical('Error while checking element in blockElementCallback', err);
                 return true;
             }
         }
@@ -22581,7 +22605,7 @@
                         return true;
                     }
                 } catch (err) {
-                    logger$5.critical('Error while checking selector: ' + sel, err);
+                    logger$6.critical('Error while checking selector: ' + sel, err);
                 }
             }
         }
@@ -23137,7 +23161,7 @@
      *
      */
 
-    var logger$4 = console_with_prefix('network-plugin');
+    var logger$5 = console_with_prefix('network-plugin');
 
     /**
      * Get the time origin for converting performance timestamps to absolute timestamps.
@@ -23289,7 +23313,7 @@
             return str;
         }
         if (str.length > MAX_BODY_SIZE) {
-            logger$4.error('Body truncated from ' + str.length + ' to ' + MAX_BODY_SIZE + ' characters');
+            logger$5.error('Body truncated from ' + str.length + ' to ' + MAX_BODY_SIZE + ' characters');
             return str.substring(0, MAX_BODY_SIZE) + '... [truncated]';
         }
         return str;
@@ -23303,7 +23327,7 @@
      */
     function initPerformanceObserver(cb, win, options) {
         if (!win.PerformanceObserver) {
-            logger$4.error('PerformanceObserver not supported');
+            logger$5.error('PerformanceObserver not supported');
             return function() {
                 //
             };
@@ -23456,7 +23480,7 @@
             attempt = 0;
         }
         if (attempt > 10) {
-            logger$4.error('Cannot find performance entry');
+            logger$5.error('Cannot find performance entry');
             return Promise.resolve(null);
         }
         var urlPerformanceEntries = /** @type {PerformanceResourceTiming[]} */ (
@@ -23577,7 +23601,7 @@
                         )
                             .then(function(entry) {
                                 if (!entry) {
-                                    logger$4.error('Failed to get performance entry for XHR request to ' + req.url);
+                                    logger$5.error('Failed to get performance entry for XHR request to ' + req.url);
                                     return;
                                 }
                                 /** @type {NetworkRequest} */
@@ -23597,7 +23621,7 @@
                                 cb({ requests: [request] });
                             })
                             .catch(function(e) {
-                                logger$4.error('Error recording XHR request to ' + req.url + ': ' + String(e));
+                                logger$5.error('Error recording XHR request to ' + req.url + ': ' + String(e));
                             });
                     });
 
@@ -23689,7 +23713,7 @@
                     })
                     .then(function(entry) {
                         if (!entry) {
-                            logger$4.error('Failed to get performance entry for fetch request to ' + req.url);
+                            logger$5.error('Failed to get performance entry for fetch request to ' + req.url);
                             return;
                         }
                         /** @type {NetworkRequest} */
@@ -23709,7 +23733,7 @@
                         cb({ requests: [request] });
                     })
                     .catch(function (e) {
-                        logger$4.error('Error recording fetch request to ' + req.url + ': ' + String(e));
+                        logger$5.error('Error recording fetch request to ' + req.url + ': ' + String(e));
                     });
 
                 return originalFetchPromise;
@@ -23782,7 +23806,7 @@
      */
 
 
-    var logger$3 = console_with_prefix('recorder');
+    var logger$4 = console_with_prefix('recorder');
     var CompressionStream = win['CompressionStream'];
 
     var RECORDER_BATCHER_LIB_CONFIG = {
@@ -23876,14 +23900,15 @@
 
         this.recordMaxMs = MAX_RECORDING_MS;
         this.recordMinMs = 0;
+        this._recordMinMsCheckStart = null;
 
         // disable persistence if localStorage is not supported
         // request-queue will automatically disable persistence if indexedDB fails to initialize
-        var usePersistence = localStorageSupported(options.sharedLockStorage, true) && !this.getConfig('disable_persistence');
+        var usePersistence = localStorageSupported(options.sharedLockStorage || getLocalStorage(), true) && !this.getConfig('disable_persistence');
 
         // each replay has its own batcher key to avoid conflicts between rrweb events of different recordings
         this.batcherKey = '__mprec_' + this.getConfig('name') + '_' + this.getConfig('token') + '_' + this.replayId;
-        this.queueStorage = new IDBStorageWrapper(RECORDING_EVENTS_STORE_NAME);
+        this.queueStorage = new IDBStorageWrapper(MIXPANEL_BROWSER_DB_NAME, RECORDING_EVENTS_STORE_NAME, RECORDER_VERSION_DATA);
         this.batcher = new RequestBatcher(this.batcherKey, {
             errorReporter: this.reportError.bind(this),
             flushOnlyOnInterval: true,
@@ -23962,14 +23987,14 @@
         }
 
         if (this._stopRecording !== null) {
-            logger$3.log('Recording already in progress, skipping startRecording.');
+            logger$4.log('Recording already in progress, skipping startRecording.');
             return;
         }
 
         this.recordMaxMs = this.getConfig('record_max_ms');
         if (this.recordMaxMs > MAX_RECORDING_MS) {
             this.recordMaxMs = MAX_RECORDING_MS;
-            logger$3.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
+            logger$4.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
         }
 
         if (!this.maxExpires) {
@@ -23991,6 +24016,7 @@
             // this also applies if the minimum recording length has not been hit yet
             // so that we don't send data until we know the recording will be long enough
             this.batcher.stop();
+            this._recordMinMsCheckStart = null;
         } else {
             this.batcher.start();
         }
@@ -24033,7 +24059,7 @@
             );
         }
 
-        var validatedOrigins = validateAllowedOrigins(this.getConfig('record_allowed_iframe_origins'), logger$3);
+        var validatedOrigins = validateAllowedOrigins(this.getConfig('record_allowed_iframe_origins'), logger$4);
 
         try {
             this._stopRecording = this._rrwebRecord({
@@ -24042,9 +24068,11 @@
                         this._onIdleTimeout();
                         return;
                     }
+                    if (this._recordMinMsCheckStart === null) {
+                        this._recordMinMsCheckStart = ev.timestamp;
+                    }
                     if (isUserEvent(ev)) {
-                        if (this.batcher.stopped && new Date().getTime() - this.replayStartTime >= this.recordMinMs) {
-                            // start flushing again after user activity
+                        if (this.batcher.stopped && ev.timestamp - this._recordMinMsCheckStart >= this.recordMinMs) {
                             this.batcher.start();
                         }
                         resetIdleTimeout();
@@ -24295,14 +24323,14 @@
 
 
     SessionRecording.prototype.reportError = function(msg, err) {
-        logger$3.error.apply(logger$3.error, arguments);
+        logger$4.error.apply(logger$4.error, arguments);
         try {
             if (!err && !(msg instanceof Error)) {
                 msg = new Error(msg);
             }
             this.getConfig('error_reporter')(msg, err);
         } catch(err) {
-            logger$3.error(err);
+            logger$4.error(err);
         }
     };
 
@@ -24331,7 +24359,7 @@
         var configValue = this.getConfig('record_min_ms');
 
         if (configValue > MAX_VALUE_FOR_MIN_RECORDING_MS) {
-            logger$3.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
+            logger$4.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
             return MAX_VALUE_FOR_MIN_RECORDING_MS;
         }
 
@@ -24373,7 +24401,7 @@
      */
     var RecordingRegistry = function (options) {
         /** @type {IDBStorageWrapper} */
-        this.idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
+        this.idb = new IDBStorageWrapper(MIXPANEL_BROWSER_DB_NAME, RECORDING_REGISTRY_STORE_NAME, RECORDER_VERSION_DATA);
         this.errorReporter = options.errorReporter;
         this.mixpanelInstance = options.mixpanelInstance;
         this.sharedLockStorage = options.sharedLockStorage;
@@ -24494,7 +24522,7 @@
             .catch(this.handleError.bind(this));
     };
 
-    var logger$2 = console_with_prefix('recorder');
+    var logger$3 = console_with_prefix('recorder');
 
     /**
      * Recorder API: bundles rrweb and and exposes methods to start and stop recordings.
@@ -24510,7 +24538,7 @@
          */
         this.recordingRegistry = new RecordingRegistry({
             mixpanelInstance: this.mixpanelInstance,
-            errorReporter: logger$2.error,
+            errorReporter: logger$3.error,
             sharedLockStorage: sharedLockStorage
         });
         this._flushInactivePromise = this.recordingRegistry.flushInactiveRecordings();
@@ -24522,17 +24550,17 @@
     MixpanelRecorder.prototype.startRecording = function(options) {
         options = options || {};
         if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
-            logger$2.log('Recording already in progress, skipping startRecording.');
+            logger$3.log('Recording already in progress, skipping startRecording.');
             return;
         }
 
         var onIdleTimeout = function () {
-            logger$2.log('Idle timeout reached, restarting recording.');
+            logger$3.log('Idle timeout reached, restarting recording.');
             this.resetRecording();
         }.bind(this);
 
         var onMaxLengthReached = function () {
-            logger$2.log('Max recording length reached, stopping recording.');
+            logger$3.log('Max recording length reached, stopping recording.');
             this.resetRecording();
         }.bind(this);
 
@@ -24602,7 +24630,7 @@
                 } else if (startNewIfInactive) {
                     return this.startRecording({shouldStopBatcher: false});
                 } else {
-                    logger$2.log('No resumable recording found.');
+                    logger$3.log('No resumable recording found.');
                     return null;
                 }
             }.bind(this));
@@ -25267,7 +25295,7 @@
             observer.observe(shadowRoot, this.observerConfig);
             this.shadowObservers.push(observer);
         } catch (e) {
-            logger$5.critical('Error while observing shadow root', e);
+            logger$6.critical('Error while observing shadow root', e);
         }
     };
 
@@ -25278,7 +25306,7 @@
         }
 
         if (!weakSetSupported()) {
-            logger$5.critical('Shadow DOM observation unavailable: WeakSet not supported');
+            logger$6.critical('Shadow DOM observation unavailable: WeakSet not supported');
             return;
         }
 
@@ -25294,7 +25322,7 @@
             try {
                 this.shadowObservers[i].disconnect();
             } catch (e) {
-                logger$5.critical('Error while disconnecting shadow DOM observer', e);
+                logger$6.critical('Error while disconnecting shadow DOM observer', e);
             }
         }
         this.shadowObservers = [];
@@ -25482,7 +25510,7 @@
 
                 this.mutationObserver.observe(document.body || document.documentElement, MUTATION_OBSERVER_CONFIG);
             } catch (e) {
-                logger$5.critical('Error while setting up mutation observer', e);
+                logger$6.critical('Error while setting up mutation observer', e);
             }
         }
 
@@ -25497,7 +25525,7 @@
                 );
                 this.shadowDOMObserver.start();
             } catch (e) {
-                logger$5.critical('Error while setting up shadow DOM observer', e);
+                logger$6.critical('Error while setting up shadow DOM observer', e);
                 this.shadowDOMObserver = null;
             }
         }
@@ -25524,7 +25552,7 @@
             try {
                 listener.target.removeEventListener(listener.event, listener.handler, listener.options);
             } catch (e) {
-                logger$5.critical('Error while removing event listener', e);
+                logger$6.critical('Error while removing event listener', e);
             }
         }
         this.eventListeners = [];
@@ -25533,7 +25561,7 @@
             try {
                 this.mutationObserver.disconnect();
             } catch (e) {
-                logger$5.critical('Error while disconnecting mutation observer', e);
+                logger$6.critical('Error while disconnecting mutation observer', e);
             }
             this.mutationObserver = null;
         }
@@ -25542,7 +25570,7 @@
             try {
                 this.shadowDOMObserver.stop();
             } catch (e) {
-                logger$5.critical('Error while stopping shadow DOM observer', e);
+                logger$6.critical('Error while stopping shadow DOM observer', e);
             }
             this.shadowDOMObserver = null;
         }
@@ -25620,7 +25648,7 @@
 
     Autocapture.prototype.init = function() {
         if (!minDOMApisSupported()) {
-            logger$5.critical('Autocapture unavailable: missing required DOM APIs');
+            logger$6.critical('Autocapture unavailable: missing required DOM APIs');
             return;
         }
         this.initPageListeners();
@@ -25660,7 +25688,7 @@
             try {
                 return !urlMatchesRegexList(currentUrl, allowUrlRegexes);
             } catch (err) {
-                logger$5.critical('Error while checking block URL regexes: ', err);
+                logger$6.critical('Error while checking block URL regexes: ', err);
                 return true;
             }
         }
@@ -25673,7 +25701,7 @@
         try {
             return urlMatchesRegexList(currentUrl, blockUrlRegexes);
         } catch (err) {
-            logger$5.critical('Error while checking block URL regexes: ', err);
+            logger$6.critical('Error while checking block URL regexes: ', err);
             return true;
         }
     };
@@ -25811,7 +25839,7 @@
             return;
         }
 
-        logger$5.log('Initializing scroll depth tracking');
+        logger$6.log('Initializing scroll depth tracking');
 
         this.maxScrollViewDepth = Math.max(document$1.documentElement.clientHeight, win.innerHeight || 0);
 
@@ -25832,12 +25860,12 @@
     };
 
     Autocapture.prototype.initClickTracking = function() {
-        win.removeEventListener(EV_CLICK, this.listenerClick);
+        win.removeEventListener(EV_CLICK, this.listenerClick, true);
 
         if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.get_config('record_heatmap_data')) {
             return;
         }
-        logger$5.log('Initializing click tracking');
+        logger$6.log('Initializing click tracking');
 
         this.listenerClick = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.is_recording_heatmap_data()) {
@@ -25845,7 +25873,7 @@
             }
             this.trackDomEvent(ev, MP_EV_CLICK);
         }.bind(this);
-        win.addEventListener(EV_CLICK, this.listenerClick);
+        win.addEventListener(EV_CLICK, this.listenerClick, true);
     };
 
     Autocapture.prototype.initDeadClickTracking = function() {
@@ -25856,7 +25884,7 @@
             return;
         }
 
-        logger$5.log('Initializing dead click tracking');
+        logger$6.log('Initializing dead click tracking');
         if (!this._deadClickTracker) {
             this._deadClickTracker = new DeadClickTracker(function(deadClickEvent) {
                 this.trackDomEvent(deadClickEvent, MP_EV_DEAD_CLICK);
@@ -25880,17 +25908,17 @@
                 }
                 this._deadClickTracker.trackClick(ev, normalizedConfig);
             }.bind(this);
-            win.addEventListener(EV_CLICK, this.listenerDeadClick);
+            win.addEventListener(EV_CLICK, this.listenerDeadClick, true);
         }
     };
 
     Autocapture.prototype.initInputTracking = function() {
-        win.removeEventListener(EV_CHANGE, this.listenerChange);
+        win.removeEventListener(EV_CHANGE, this.listenerChange, true);
 
         if (!this.getConfig(CONFIG_TRACK_INPUT)) {
             return;
         }
-        logger$5.log('Initializing input tracking');
+        logger$6.log('Initializing input tracking');
 
         this.listenerChange = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_INPUT)) {
@@ -25898,20 +25926,21 @@
             }
             this.trackDomEvent(ev, MP_EV_INPUT);
         }.bind(this);
-        win.addEventListener(EV_CHANGE, this.listenerChange);
+        win.addEventListener(EV_CHANGE, this.listenerChange, true);
     };
 
     Autocapture.prototype.initPageviewTracking = function() {
         win.removeEventListener(EV_MP_LOCATION_CHANGE, this.listenerLocationchange);
 
-        if (!this.pageviewTrackingConfig()) {
+        if (!this.pageviewTrackingConfig() && !this.mp.get_config('record_heatmap_data')) {
             return;
         }
-        logger$5.log('Initializing pageview tracking');
+        logger$6.log('Initializing pageview tracking');
 
         var previousTrackedUrl = '';
         var tracked = false;
-        if (!this.currentUrlBlocked()) {
+        // Track initial pageview if pageview tracking enabled OR heatmap recording is active
+        if ((this.pageviewTrackingConfig() || this.mp.is_recording_heatmap_data()) && !this.currentUrlBlocked()) {
             tracked = this.mp.track_pageview(DEFAULT_PROPS);
         }
         if (tracked) {
@@ -25927,6 +25956,10 @@
             var shouldTrack = false;
             var didPathChange = currentUrl.split('#')[0].split('?')[0] !== previousTrackedUrl.split('#')[0].split('?')[0];
             var trackPageviewOption = this.pageviewTrackingConfig();
+            if (!trackPageviewOption && this.mp.is_recording_heatmap_data()) {
+                trackPageviewOption = PAGEVIEW_OPTION_FULL_URL;
+            }
+
             if (trackPageviewOption === PAGEVIEW_OPTION_FULL_URL) {
                 shouldTrack = currentUrl !== previousTrackedUrl;
             } else if (trackPageviewOption === PAGEVIEW_OPTION_URL_WITH_PATH_AND_QUERY_STRING) {
@@ -25942,7 +25975,7 @@
                 }
                 if (didPathChange) {
                     this.lastScrollCheckpoint = 0;
-                    logger$5.log('Path change: re-initializing scroll depth checkpoints');
+                    logger$6.log('Path change: re-initializing scroll depth checkpoints');
                 }
             }
         }.bind(this));
@@ -25950,14 +25983,14 @@
     };
 
     Autocapture.prototype.initRageClickTracking = function() {
-        win.removeEventListener(EV_CLICK, this.listenerRageClick);
+        win.removeEventListener(EV_CLICK, this.listenerRageClick, true);
 
         var rageClickConfig = this._getClickTrackingConfig(CONFIG_TRACK_RAGE_CLICK);
         if (!rageClickConfig && !this.mp.get_config('record_heatmap_data')) {
             return;
         }
 
-        logger$5.log('Initializing rage click tracking');
+        logger$6.log('Initializing rage click tracking');
         if (!this._rageClickTracker) {
             this._rageClickTracker = new RageClickTracker();
         }
@@ -25976,7 +26009,7 @@
                 this.trackDomEvent(ev, MP_EV_RAGE_CLICK);
             }
         }.bind(this);
-        win.addEventListener(EV_CLICK, this.listenerRageClick);
+        win.addEventListener(EV_CLICK, this.listenerRageClick, true);
     };
 
     Autocapture.prototype.initScrollTracking = function() {
@@ -25987,7 +26020,7 @@
         if (!this.getConfig(CONFIG_TRACK_SCROLL)) {
             return;
         }
-        logger$5.log('Initializing scroll tracking');
+        logger$6.log('Initializing scroll tracking');
         this.lastScrollCheckpoint = 0;
 
         var scrollTrackFunction = function() {
@@ -26024,7 +26057,7 @@
                     }
                 }
             } catch (err) {
-                logger$5.critical('Error while calculating scroll percentage', err);
+                logger$6.critical('Error while calculating scroll percentage', err);
             }
             if (shouldTrack) {
                 this.mp.track(MP_EV_SCROLL, props);
@@ -26037,12 +26070,12 @@
     };
 
     Autocapture.prototype.initSubmitTracking = function() {
-        win.removeEventListener(EV_SUBMIT, this.listenerSubmit);
+        win.removeEventListener(EV_SUBMIT, this.listenerSubmit, true);
 
         if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
             return;
         }
-        logger$5.log('Initializing submit tracking');
+        logger$6.log('Initializing submit tracking');
 
         this.listenerSubmit = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
@@ -26050,7 +26083,7 @@
             }
             this.trackDomEvent(ev, MP_EV_SUBMIT);
         }.bind(this);
-        win.addEventListener(EV_SUBMIT, this.listenerSubmit);
+        win.addEventListener(EV_SUBMIT, this.listenerSubmit, true);
     };
 
     Autocapture.prototype.initPageLeaveTracking = function() {
@@ -26064,7 +26097,7 @@
             return;
         }
 
-        logger$5.log('Initializing page visibility tracking.');
+        logger$6.log('Initializing page visibility tracking.');
         this._initScrollDepthTracking();
         var previousTrackedUrl = _.info.currentUrl();
 
@@ -26106,7 +26139,7 @@
 
     Autocapture.prototype.stopDeadClickTracking = function() {
         if (this.listenerDeadClick) {
-            win.removeEventListener(EV_CLICK, this.listenerDeadClick);
+            win.removeEventListener(EV_CLICK, this.listenerDeadClick, true);
             this.listenerDeadClick = null;
         }
 
@@ -26149,10 +26182,183 @@
         return win[TARGETING_GLOBAL_NAME];
     };
 
+    var logger$2 = console_with_prefix('flags');
+
+    var MIXPANEL_FLAGS_DB_NAME = 'mixpanelFlagsDb';
+    var FLAGS_STORE_NAME = 'mixpanelFlags';
+
+    // Keeping these two properties closeby, as adding additional stores to a DB in IndexedDB requires a version increment
+    var FLAGS_VERSION_DATA = { version: 1, storeNames: [FLAGS_STORE_NAME] };
+
+    var PERSISTED_VARIANTS_KEY_PREFIX = 'persisted_variants_for_';
+    var DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+
+    var VariantLookupPolicy = Object.freeze({
+        NETWORK_ONLY: 'networkOnly',
+        NETWORK_FIRST: 'networkFirst',
+        PERSISTENCE_UNTIL_NETWORK_SUCCESS: 'persistenceUntilNetworkSuccess'
+    });
+
+    var VALID_POLICIES = [
+        VariantLookupPolicy.NETWORK_ONLY,
+        VariantLookupPolicy.NETWORK_FIRST,
+        VariantLookupPolicy.PERSISTENCE_UNTIL_NETWORK_SUCCESS
+    ];
+
+    /**
+     * Module for handling the storage and retrieval of persisted feature flag variants.
+     */
+    var FeatureFlagPersistence = function(persistenceConfig, token, isGloballyDisabled) {
+        this.idb = new IDBStorageWrapper(MIXPANEL_FLAGS_DB_NAME, FLAGS_STORE_NAME, FLAGS_VERSION_DATA);
+        this.persistenceConfig = persistenceConfig;
+        this.persistedVariantsKey = PERSISTED_VARIANTS_KEY_PREFIX + token;
+        this.isGloballyDisabled = isGloballyDisabled || function() { return false; };
+    };
+
+    FeatureFlagPersistence.prototype.getPolicy = function() {
+        if (this.isGloballyDisabled() || !this._isConfigValid()) {
+            return VariantLookupPolicy.NETWORK_ONLY;
+        }
+        return this.persistenceConfig['variantLookupPolicy'];
+    };
+
+    FeatureFlagPersistence.prototype.getTtlMs = function() {
+        if (!this._isConfigValid()) {
+            return DEFAULT_TTL_MS;
+        }
+        var configuredTtl = this.persistenceConfig['persistenceTtlMs'];
+        return (configuredTtl === undefined || configuredTtl === null) ? DEFAULT_TTL_MS : configuredTtl;
+    };
+
+    FeatureFlagPersistence.prototype._isConfigValid = function() {
+        var config = this.persistenceConfig;
+        if (!config) {
+            return false;
+        }
+
+        if (VALID_POLICIES.indexOf(config['variantLookupPolicy']) === -1) {
+            logger$2.error('Invalid variantLookupPolicy:', config['variantLookupPolicy']);
+            return false;
+        }
+
+        if (config['persistenceTtlMs'] !== undefined &&
+            config['persistenceTtlMs'] !== null &&
+            config['persistenceTtlMs'] <= 0) {
+            logger$2.error('If provided, persistenceTtlMs must be a positive number. Provided value:', config['persistenceTtlMs']);
+            return false;
+        }
+
+        return true;
+    };
+
+    FeatureFlagPersistence.prototype.loadFlagsFromStorage = function(context) {
+        var clearAndReturnNull = _.bind(function() {
+            return this.clear().then(function() { return null; }).catch(function() { return null; });
+        }, this);
+
+        if (this.getPolicy() === VariantLookupPolicy.NETWORK_ONLY) {
+            return clearAndReturnNull();
+        }
+
+        var ttlMs = this.getTtlMs();
+
+        return this.idb.init().then(_.bind(function() {
+            return this.idb.getItem(this.persistedVariantsKey);
+        }, this)).then(_.bind(function(data) {
+            if (!data) {
+                logger$2.log('No persisted variants found in IndexedDB');
+                return null;
+            }
+
+            if (ttlMs && Date.now() - data['persistedAt'] >= ttlMs) {
+                logger$2.log('Persisted variants are expiring');
+                return null;
+            }
+
+            if (!context || data['distinctId'] !== context['distinct_id']) {
+                logger$2.log('Persisted variants found, but for a different distinct_id so clearing.');
+                return clearAndReturnNull();
+            }
+
+            var persistedFlags = new Map();
+            _.each(data['flagVariants'], function(variantData, key) {
+                persistedFlags.set(key, {
+                    'key': variantData['variant_key'],
+                    'value': variantData['variant_value'],
+                    'experiment_id': variantData['experiment_id'],
+                    'is_experiment_active': variantData['is_experiment_active'],
+                    'is_qa_tester': variantData['is_qa_tester'],
+                    'variant_source': 'persistence',
+                    'persisted_at_in_ms': data['persistedAt'],
+                    'ttl_in_ms': ttlMs
+                });
+            });
+
+            logger$2.log('Loaded', persistedFlags.size, 'variants from IndexedDB for distinct_id', data['distinctId']);
+
+            return {
+                flags: persistedFlags,
+                pendingFirstTimeEvents: data['pendingFirstTimeEvents'] || {},
+                persistedAtMs: data['persistedAt'],
+                ttlMs: ttlMs
+            };
+        }, this)).catch(_.bind(function(error) {
+            logger$2.error('Failed to load persisted variants from IndexedDB, so clearing', error);
+            return clearAndReturnNull();
+        }, this));
+    };
+
+    FeatureFlagPersistence.prototype.save = function(context, flagsMap, pendingFirstTimeEvents) {
+        if (this.getPolicy() === VariantLookupPolicy.NETWORK_ONLY) {
+            return Promise.resolve();
+        }
+
+        var flagVariants = {};
+        flagsMap.forEach(function(variant, key) {
+            flagVariants[key] = {
+                'variant_key': variant['key'],
+                'variant_value': variant['value'],
+                'experiment_id': variant['experiment_id'],
+                'is_experiment_active': variant['is_experiment_active'],
+                'is_qa_tester': variant['is_qa_tester']
+            };
+        });
+
+        var data = {
+            'persistedAt': Date.now(),
+            'distinctId': context && context['distinct_id'],
+            'context': context,
+            'flagVariants': flagVariants,
+            'pendingFirstTimeEvents': pendingFirstTimeEvents || {}
+        };
+
+        return this.idb.init().then(_.bind(function() {
+            return this.idb.setItem(this.persistedVariantsKey, data);
+        }, this)).then(function() {
+            logger$2.log('Saved', flagsMap.size, 'variants to IndexedDB for distinct_id', data['distinctId']);
+        }).catch(function(error) {
+            logger$2.error('Failed to persist variants to IndexedDB:', error);
+        });
+    };
+
+    FeatureFlagPersistence.prototype.clear = function() {
+        if (this.isGloballyDisabled()) {
+            return Promise.resolve();
+        }
+        return this.idb.init().then(_.bind(function() {
+            return this.idb.removeItem(this.persistedVariantsKey);
+        }, this)).then(function() {
+            logger$2.log('Cleared persisted variants from IndexedDB');
+        }).catch(function(error) {
+            logger$2.error('Failed to clear persisted variants from IndexedDB:', error);
+        });
+    };
+
     var logger$1 = console_with_prefix('flags');
     var FLAGS_CONFIG_KEY = 'flags';
 
     var CONFIG_CONTEXT = 'context';
+    var CONFIG_PERSISTENCE = 'persistence';
     var CONFIG_DEFAULTS = {};
     CONFIG_DEFAULTS[CONFIG_CONTEXT] = {};
 
@@ -26175,6 +26381,13 @@
         return eventKey.split(':')[0];
     };
 
+    var withFallbackSource = function(fallback) {
+        if (_.isObject(fallback)) {
+            return _.extend({}, fallback, {'variant_source': 'fallback'});
+        }
+        return {'value': fallback, 'variant_source': 'fallback'};
+    };
+
     /**
      * FeatureFlagManager: support for Mixpanel's feature flagging product
      * @constructor
@@ -26197,13 +26410,63 @@
         }
 
         this.flags = null;
-        this.fetchFlags().catch(function() {
-            logger$1.error('Error fetching flags during init');
-        });
-
         this.trackedFeatures = new Set();
         this.pendingFirstTimeEvents = {};
         this.activatedFirstTimeEvents = {};
+        this._loadedPersistedAtMs = null;
+        this._loadedTtlMs = null;
+
+        this.persistence = new FeatureFlagPersistence(
+            this.getConfig(CONFIG_PERSISTENCE),
+            this.getMpConfig('token'),
+            _.bind(function() { return this.getMpConfig('disable_persistence'); }, this)
+        );
+
+        this.persistenceLoadedPromise = this.persistence.loadFlagsFromStorage(this._buildContext())
+            .then(_.bind(function(loaded) {
+                if (loaded) {
+                    this.flags = loaded.flags;
+                    this.pendingFirstTimeEvents = loaded.pendingFirstTimeEvents;
+                    this._loadedPersistedAtMs = loaded.persistedAtMs;
+                    this._loadedTtlMs = loaded.ttlMs;
+                }
+            }, this));
+
+        return this.persistenceLoadedPromise
+            .then(_.bind(function() {
+                return this.fetchFlags();
+            }, this))
+            .catch(function() {
+                logger$1.error('Error initializing feature flags');
+            });
+    };
+
+    FeatureFlagManager.prototype._buildContext = function() {
+        return _.extend(
+            {'distinct_id': this.getMpProperty('distinct_id'), 'device_id': this.getMpProperty('$device_id')},
+            this.getConfig(CONFIG_CONTEXT)
+        );
+    };
+
+    FeatureFlagManager.prototype.reset = function() {
+        if (!this.persistence) {
+            return Promise.resolve();
+        }
+
+        this.flags = null;
+        this.pendingFirstTimeEvents = {};
+        this.activatedFirstTimeEvents = {};
+        this.trackedFeatures = new Set();
+        this.fetchPromise = null;
+        this._fetchInProgressStartTime = null;
+        this._loadedPersistedAtMs = null;
+        this._loadedTtlMs = null;
+
+        return this.persistence.clear().then(_.bind(function() {
+            return this.fetchFlags();
+        }, this)).catch(function() {
+            logger$1.error('Error during flags reset');
+        });
     };
 
     FeatureFlagManager.prototype.getFullConfig = function() {
@@ -26260,12 +26523,11 @@
             return Promise.resolve();
         }
 
-        var distinctId = this.getMpProperty('distinct_id');
-        var deviceId = this.getMpProperty('$device_id');
+        var context = this._buildContext();
+        var distinctId = context['distinct_id'];
         var traceparent = generateTraceparent();
         logger$1.log('Fetching flags for distinct ID: ' + distinctId);
 
-        var context = _.extend({'distinct_id': distinctId, 'device_id': deviceId}, this.getConfig(CONFIG_CONTEXT));
         var searchParams = new URLSearchParams();
         searchParams.set('context', JSON.stringify(context));
         searchParams.set('token', this.getMpConfig('token'));
@@ -26315,7 +26577,8 @@
                         'value': data['variant_value'],
                         'experiment_id': data['experiment_id'],
                         'is_experiment_active': data['is_experiment_active'],
-                        'is_qa_tester': data['is_qa_tester']
+                        'is_qa_tester': data['is_qa_tester'],
+                        'variant_source': 'network'
                     });
                 }
             }, this);
@@ -26357,10 +26620,15 @@
             }
 
             this.flags = flags;
+            this.trackedFeatures = new Set();
             this.pendingFirstTimeEvents = pendingFirstTimeEvents;
+            this._loadedPersistedAtMs = null;
+            this._loadedTtlMs = null;
             this._traceparent = traceparent;
 
             this._loadTargetingIfNeeded();
+
+            this.persistence.save(context, this.flags, this.pendingFirstTimeEvents);
         }.bind(this)).catch(function(error) {
             if (this._fetchInProgressStartTime) {
                 this.markFetchComplete();
@@ -26520,6 +26788,7 @@
             };
 
             this.flags.set(flagKey, newVariant);
+            this.trackedFeatures.delete(flagKey);
             this.activatedFirstTimeEvents[eventKey] = true;
 
             this.recordFirstTimeEvent(
@@ -26531,8 +26800,8 @@
     };
 
     FeatureFlagManager.prototype.getFirstTimeEventApiRoute = function(flagId) {
-        // Construct URL: {api_host}/flags/{flagId}/first-time-events
-        return this.getFullApiRoute() + '/' + flagId + '/first-time-events';
+        var base = this.getFullApiRoute().replace(/\/$/, '');
+        return base + '/' + flagId + '/first-time-events';
     };
 
     FeatureFlagManager.prototype.recordFirstTimeEvent = function(flagId, projectId, firstTimeEventHash) {
@@ -26569,35 +26838,106 @@
     };
 
     FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
-        if (!this.fetchPromise) {
+        if (!this.persistenceLoadedPromise) {
             return new Promise(function(resolve) {
                 logger$1.critical('Feature Flags not initialized');
-                resolve(fallback);
+                resolve(withFallbackSource(fallback));
             });
         }
 
-        return this.fetchPromise.then(function() {
-            return this.getVariantSync(featureName, fallback);
-        }.bind(this)).catch(function(error) {
-            logger$1.error(error);
-            return fallback;
-        });
+        var policy = this.persistence.getPolicy();
+
+        return this.persistenceLoadedPromise.then(_.bind(function() {
+            // Serve from persistence until the network completes a successful fetch. If a non-expired cached value is available, return it without waiting on the in-flight fetch.
+            if (policy === VariantLookupPolicy.PERSISTENCE_UNTIL_NETWORK_SUCCESS) {
+                if (this.areFlagsReady() && !this._loadedPersistenceIsStale()) {
+                    return this.getVariantSync(featureName, fallback);
+                }
+                if (!this.fetchPromise) {
+                    return withFallbackSource(fallback);
+                }
+                return this.fetchPromise.then(_.bind(function() {
+                    return this.getVariantSync(featureName, fallback);
+                }, this)).catch(function(error) {
+                    logger$1.error(error);
+                    return withFallbackSource(fallback);
+                });
+            }
+
+            var serve = _.bind(function() { return this.getVariantSync(featureName, fallback); }, this);
+            if (!this.fetchPromise) {
+                return withFallbackSource(fallback);
+            }
+            return this.fetchPromise.then(serve).catch(serve);
+        }, this));
+    };
+
+    FeatureFlagManager.prototype._loadedPersistenceIsStale = function() {
+        if (!this._loadedPersistedAtMs || !this._loadedTtlMs) {
+            return false;
+        }
+        return Date.now() - this._loadedPersistedAtMs >= this._loadedTtlMs;
     };
 
     FeatureFlagManager.prototype.getVariantSync = function(featureName, fallback) {
+        if (this._loadedPersistenceIsStale()) {
+            logger$1.log('Loaded persisted variants are past TTL so returning fallback for "' + featureName + '"');
+            return withFallbackSource(fallback);
+        }
         if (!this.areFlagsReady()) {
             logger$1.log('Flags not loaded yet');
-            return fallback;
+            return withFallbackSource(fallback);
         }
         var feature = this.flags.get(featureName);
         if (!feature) {
             logger$1.log('No flag found: "' + featureName + '"');
-            return fallback;
+            return withFallbackSource(fallback);
         }
         this.trackFeatureCheck(featureName, feature);
         return feature;
     };
 
+    FeatureFlagManager.prototype.getAllVariants = function() {
+        if (!this.persistenceLoadedPromise) {
+            logger$1.critical('Feature Flags not initialized');
+            return Promise.resolve(new Map());
+        }
+
+        var policy = this.persistence.getPolicy();
+
+        return this.persistenceLoadedPromise.then(_.bind(function() {
+            // Serve from persistence until the network completes a successful fetch. If a non-expired cached value is available, return it without waiting on the in-flight fetch.
+            if (policy === VariantLookupPolicy.PERSISTENCE_UNTIL_NETWORK_SUCCESS) {
+                if (this.areFlagsReady() && !this._loadedPersistenceIsStale()) {
+                    return this.getAllVariantsSync();
+                }
+                if (!this.fetchPromise) {
+                    return new Map();
+                }
+                return this.fetchPromise.then(_.bind(function() {
+                    return this.getAllVariantsSync();
+                }, this)).catch(function(error) {
+                    logger$1.error(error);
+                    return new Map();
+                });
+            }
+
+            var serve = _.bind(this.getAllVariantsSync, this);
+            if (!this.fetchPromise) {
+                return new Map();
+            }
+            return this.fetchPromise.then(serve).catch(serve);
+        }, this));
+    };
+
+    FeatureFlagManager.prototype.getAllVariantsSync = function() {
+        if (this._loadedPersistenceIsStale()) {
+            logger$1.log('Loaded persisted variants are past TTL so returning empty Map');
+            return new Map();
+        }
+        return this.flags || new Map();
+    };
+
     FeatureFlagManager.prototype.getVariantValue = function(featureName, fallbackValue) {
         return this.getVariant(featureName, {'value': fallbackValue}).then(function(feature) {
             return feature['value'];
@@ -26636,6 +26976,10 @@
         return val;
     };
 
+    function isPresent(v) {
+        return v !== undefined && v !== null;
+    }
+
     FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature) {
         if (this.trackedFeatures.has(featureName)) {
             return;
@@ -26646,21 +26990,30 @@
             'Experiment name': featureName,
             'Variant name': feature['key'],
             '$experiment_type': 'feature_flag',
-            'Variant fetch start time': new Date(this._fetchStartTime).toISOString(),
-            'Variant fetch complete time': new Date(this._fetchCompleteTime).toISOString(),
+            'Variant fetch start time': isPresent(this._fetchStartTime) ? new Date(this._fetchStartTime).toISOString() : null,
+            'Variant fetch complete time': isPresent(this._fetchCompleteTime) ? new Date(this._fetchCompleteTime).toISOString() : null,
             'Variant fetch latency (ms)': this._fetchLatency,
             'Variant fetch traceparent': this._traceparent,
         };
 
-        if (feature['experiment_id'] !== 'undefined') {
+        if (isPresent(feature['experiment_id'])) {
             trackingProperties['$experiment_id'] = feature['experiment_id'];
         }
-        if (feature['is_experiment_active'] !== 'undefined') {
+        if (isPresent(feature['is_experiment_active'])) {
             trackingProperties['$is_experiment_active'] = feature['is_experiment_active'];
         }
-        if (feature['is_qa_tester'] !== 'undefined') {
+        if (isPresent(feature['is_qa_tester'])) {
             trackingProperties['$is_qa_tester'] = feature['is_qa_tester'];
         }
+        if (isPresent(feature['variant_source'])) {
+            trackingProperties['$variant_source'] = feature['variant_source'];
+        }
+        if (isPresent(feature['persisted_at_in_ms'])) {
+            trackingProperties['$persisted_at_in_ms'] = feature['persisted_at_in_ms'];
+        }
+        if (isPresent(feature['ttl_in_ms'])) {
+            trackingProperties['$ttl_in_ms'] = feature['ttl_in_ms'];
+        }
 
         this.track('$experiment_started', trackingProperties);
     };
@@ -26684,6 +27037,8 @@
     FeatureFlagManager.prototype['are_flags_ready'] = FeatureFlagManager.prototype.areFlagsReady;
     FeatureFlagManager.prototype['get_variant'] = FeatureFlagManager.prototype.getVariant;
     FeatureFlagManager.prototype['get_variant_sync'] = FeatureFlagManager.prototype.getVariantSync;
+    FeatureFlagManager.prototype['get_all_variants'] = FeatureFlagManager.prototype.getAllVariants;
+    FeatureFlagManager.prototype['get_all_variants_sync'] = FeatureFlagManager.prototype.getAllVariantsSync;
     FeatureFlagManager.prototype['get_variant_value'] = FeatureFlagManager.prototype.getVariantValue;
     FeatureFlagManager.prototype['get_variant_value_sync'] = FeatureFlagManager.prototype.getVariantValueSync;
     FeatureFlagManager.prototype['is_enabled'] = FeatureFlagManager.prototype.isEnabled;
@@ -26736,7 +27091,7 @@
             return PromisePolyfill.resolve(false);
         }
 
-        var recording_registry_idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
+        var recording_registry_idb = new IDBStorageWrapper(MIXPANEL_BROWSER_DB_NAME, RECORDING_REGISTRY_STORE_NAME, RECORDER_VERSION_DATA);
         var tab_id = this.getTabId();
         return recording_registry_idb.init()
             .then(function () {
@@ -28663,6 +29018,7 @@
             'disable_all_events': false,
             'identify_called': false
         };
+        this._remote_settings_strict_disabled = false;
 
         // set up request queueing/batching
         this.request_batchers = {};
@@ -28737,9 +29093,6 @@
         this.flags.init();
         this['flags'] = this.flags;
 
-        this.autocapture = new Autocapture(this);
-        this.autocapture.init();
-
         this._init_tab_id();
 
         // Based on remote_settings_mode, fetch remote settings and then start session recording if applicable
@@ -28751,6 +29104,9 @@
         } else {
             this.__session_recording_init_promise = this._check_and_start_session_recording();
         }
+
+        this.autocapture = new Autocapture(this);
+        this.autocapture.init();
     };
 
     /**
@@ -28797,9 +29153,19 @@
         return this.recorderManager.checkAndStartSessionRecording(force_start);
     });
 
-    MixpanelLib.prototype._start_recording_on_event = function(event_name, properties) {
-        return this.recorderManager.startRecordingOnEvent(event_name, properties);
-    };
+    MixpanelLib.prototype._start_recording_on_event = safewrap(function(event_name, properties) {
+        // Wait for recording init to complete before evaluating event triggers.
+        // This ensures recording_event_triggers config is fully loaded when remote settings are used.
+        if (this.__session_recording_init_promise) {
+            this.__session_recording_init_promise.then(_.bind(function() {
+                // In strict mode, skip recording if remote settings failed
+                if (this._remote_settings_strict_disabled) {
+                    return;
+                }
+                return this.recorderManager.startRecordingOnEvent(event_name, properties);
+            }, this));
+        }
+    });
 
     MixpanelLib.prototype.start_session_recording = function () {
         return this._check_and_start_session_recording(true);
@@ -29098,6 +29464,7 @@
         var disableRecordingIfStrict = function() {
             if (mode === 'strict') {
                 self.set_config({'record_sessions_percent': 0});
+                self._remote_settings_strict_disabled = true;
             }
         };
 
@@ -29723,6 +30090,10 @@
             properties
         );
 
+        if (this.is_recording_heatmap_data()) {
+            event_properties['$captured_for_heatmap'] = true;
+        }
+
         return this.track(event_name, event_properties);
     });
 
@@ -30066,6 +30437,7 @@
             '$device_id': uuid
         }, '');
         this._check_and_start_session_recording();
+        this.flags.reset();
     };
 
     /**