mixpanel-browser 2.77.0 → 2.79.0

package/dist/mixpanel.amd.js

@@ -27,7 +27,7 @@ define((function () { 'use strict';
 
     var Config = {
         DEBUG: false,
-        LIB_VERSION: '2.77.0'
+        LIB_VERSION: '2.79.0'
     };
 
     // Window global names for async modules
@@ -19125,6 +19125,7 @@ define((function () { 'use strict';
     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)
         };
@@ -20071,7 +20072,8 @@ define((function () { 'use strict';
         if (_localStorageSupported !== null && !forceCheck) {
             return _localStorageSupported;
         }
-        return _localStorageSupported = _testStorageSupported(storage || win.localStorage);
+
+        return _localStorageSupported = _testStorageSupported(storage);
     };
 
     var _sessionStorageSupported = null;
@@ -20079,7 +20081,8 @@ define((function () { 'use strict';
         if (_sessionStorageSupported !== null && !forceCheck) {
             return _sessionStorageSupported;
         }
-        return _sessionStorageSupported = _testStorageSupported(storage || win.sessionStorage);
+
+        return _sessionStorageSupported = _testStorageSupported(storage);
     };
 
     function _storageWrapper(storage, name, is_supported_fn) {
@@ -20129,17 +20132,26 @@ define((function () { 'use strict';
         };
     }
 
-    // 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;
+        }
+    };
 
-    _.localStorage = _storageWrapper(windowLocalStorage, 'localStorage', localStorageSupported);
-    _.sessionStorage = _storageWrapper(windowSessionStorage, 'sessionStorage', sessionStorageSupported);
+    var getSessionStorage = function() {
+        try {
+            return win.sessionStorage; // eslint-disable-line no-restricted-properties
+        } catch (_err) {
+            return null;
+        }
+    };
+
+    _.localStorage = _storageWrapper(getLocalStorage(), 'localStorage', localStorageSupported);
+    _.sessionStorage = _storageWrapper(getSessionStorage(), 'sessionStorage', sessionStorageSupported);
 
     _.register_event = (function() {
         // written by Dean Edwards, 2005
@@ -20808,29 +20820,26 @@ define((function () { 'use strict';
     _['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);
             };
@@ -20842,8 +20851,10 @@ define((function () { 'use strict';
             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);
+                    }
                 });
             };
         });
@@ -20935,6 +20946,16 @@ define((function () { 'use strict';
         });
     };
 
+    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
      *
@@ -21235,7 +21256,7 @@ define((function () { 'use strict';
         };
     }
 
-    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
@@ -21261,7 +21282,7 @@ define((function () { 'use strict';
         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;
 
@@ -21287,7 +21308,7 @@ define((function () { 'use strict';
 
             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();
@@ -21389,10 +21410,13 @@ define((function () { 'use strict';
      * @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();
     };
 
@@ -21434,7 +21458,7 @@ define((function () { 'use strict';
         }, 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.
@@ -21459,11 +21483,11 @@ define((function () { 'use strict';
         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
 
@@ -21796,7 +21820,7 @@ define((function () { 'use strict';
     // 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
@@ -21924,7 +21948,7 @@ define((function () { 'use strict';
      */
     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();
         }
 
@@ -22101,7 +22125,7 @@ define((function () { 'use strict';
                 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) {
@@ -22114,7 +22138,7 @@ define((function () { 'use strict';
      * 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)) {
@@ -22122,7 +22146,7 @@ define((function () { 'use strict';
                 }
                 this.errorReporter(msg, err);
             } catch(err) {
-                logger$6.error(err);
+                logger$7.error(err);
             }
         }
     };
@@ -22267,7 +22291,7 @@ define((function () { 'use strict';
 
     var MAX_DEPTH = 5;
 
-    var logger$5 = console_with_prefix('autocapture');
+    var logger$6 = console_with_prefix('autocapture');
 
 
     function getClasses(el) {
@@ -22531,7 +22555,7 @@ define((function () { 'use strict';
                     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;
             }
         }
@@ -22548,7 +22572,7 @@ define((function () { 'use strict';
                     return true;
                 }
             } catch (err) {
-                logger$5.critical('Error while checking selector: ' + sel, err);
+                logger$6.critical('Error while checking selector: ' + sel, err);
             }
         }
         return false;
@@ -22563,7 +22587,7 @@ define((function () { 'use strict';
                     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;
             }
         }
@@ -22577,7 +22601,7 @@ define((function () { 'use strict';
                         return true;
                     }
                 } catch (err) {
-                    logger$5.critical('Error while checking selector: ' + sel, err);
+                    logger$6.critical('Error while checking selector: ' + sel, err);
                 }
             }
         }
@@ -23133,7 +23157,7 @@ define((function () { 'use strict';
      *
      */
 
-    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.
@@ -23285,7 +23309,7 @@ define((function () { 'use strict';
             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;
@@ -23299,7 +23323,7 @@ define((function () { 'use strict';
      */
     function initPerformanceObserver(cb, win, options) {
         if (!win.PerformanceObserver) {
-            logger$4.error('PerformanceObserver not supported');
+            logger$5.error('PerformanceObserver not supported');
             return function() {
                 //
             };
@@ -23452,7 +23476,7 @@ define((function () { 'use strict';
             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[]} */ (
@@ -23573,7 +23597,7 @@ define((function () { 'use strict';
                         )
                             .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} */
@@ -23593,7 +23617,7 @@ define((function () { 'use strict';
                                 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));
                             });
                     });
 
@@ -23685,7 +23709,7 @@ define((function () { 'use strict';
                     })
                     .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} */
@@ -23705,7 +23729,7 @@ define((function () { 'use strict';
                         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;
@@ -23778,7 +23802,7 @@ define((function () { 'use strict';
      */
 
 
-    var logger$3 = console_with_prefix('recorder');
+    var logger$4 = console_with_prefix('recorder');
     var CompressionStream = win['CompressionStream'];
 
     var RECORDER_BATCHER_LIB_CONFIG = {
@@ -23875,11 +23899,11 @@ define((function () { 'use strict';
 
         // 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,
@@ -23958,14 +23982,14 @@ define((function () { 'use strict';
         }
 
         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) {
@@ -24029,7 +24053,7 @@ define((function () { 'use strict';
             );
         }
 
-        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({
@@ -24291,14 +24315,14 @@ define((function () { 'use strict';
 
 
     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);
         }
     };
 
@@ -24327,7 +24351,7 @@ define((function () { 'use strict';
         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;
         }
 
@@ -24369,7 +24393,7 @@ define((function () { 'use strict';
      */
     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;
@@ -24490,7 +24514,7 @@ define((function () { 'use strict';
             .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.
@@ -24506,7 +24530,7 @@ define((function () { 'use strict';
          */
         this.recordingRegistry = new RecordingRegistry({
             mixpanelInstance: this.mixpanelInstance,
-            errorReporter: logger$2.error,
+            errorReporter: logger$3.error,
             sharedLockStorage: sharedLockStorage
         });
         this._flushInactivePromise = this.recordingRegistry.flushInactiveRecordings();
@@ -24518,17 +24542,17 @@ define((function () { 'use strict';
     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);
 
@@ -24598,7 +24622,7 @@ define((function () { 'use strict';
                 } 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));
@@ -25263,7 +25287,7 @@ define((function () { 'use strict';
             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);
         }
     };
 
@@ -25274,7 +25298,7 @@ define((function () { 'use strict';
         }
 
         if (!weakSetSupported()) {
-            logger$5.critical('Shadow DOM observation unavailable: WeakSet not supported');
+            logger$6.critical('Shadow DOM observation unavailable: WeakSet not supported');
             return;
         }
 
@@ -25290,7 +25314,7 @@ define((function () { 'use strict';
             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 = [];
@@ -25478,7 +25502,7 @@ define((function () { 'use strict';
 
                 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);
             }
         }
 
@@ -25493,7 +25517,7 @@ define((function () { 'use strict';
                 );
                 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;
             }
         }
@@ -25520,7 +25544,7 @@ define((function () { 'use strict';
             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 = [];
@@ -25529,7 +25553,7 @@ define((function () { 'use strict';
             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;
         }
@@ -25538,7 +25562,7 @@ define((function () { 'use strict';
             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;
         }
@@ -25616,7 +25640,7 @@ define((function () { 'use strict';
 
     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();
@@ -25656,7 +25680,7 @@ define((function () { 'use strict';
             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;
             }
         }
@@ -25669,7 +25693,7 @@ define((function () { 'use strict';
         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;
         }
     };
@@ -25807,7 +25831,7 @@ define((function () { 'use strict';
             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);
 
@@ -25833,7 +25857,7 @@ define((function () { 'use strict';
         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()) {
@@ -25852,7 +25876,7 @@ define((function () { 'use strict';
             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);
@@ -25886,7 +25910,7 @@ define((function () { 'use strict';
         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)) {
@@ -25900,14 +25924,15 @@ define((function () { 'use strict';
     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) {
@@ -25923,6 +25948,10 @@ define((function () { 'use strict';
             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) {
@@ -25938,7 +25967,7 @@ define((function () { 'use strict';
                 }
                 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));
@@ -25953,7 +25982,7 @@ define((function () { 'use strict';
             return;
         }
 
-        logger$5.log('Initializing rage click tracking');
+        logger$6.log('Initializing rage click tracking');
         if (!this._rageClickTracker) {
             this._rageClickTracker = new RageClickTracker();
         }
@@ -25983,7 +26012,7 @@ define((function () { 'use strict';
         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() {
@@ -26020,7 +26049,7 @@ define((function () { 'use strict';
                     }
                 }
             } 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);
@@ -26038,7 +26067,7 @@ define((function () { 'use strict';
         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)) {
@@ -26060,7 +26089,7 @@ define((function () { 'use strict';
             return;
         }
 
-        logger$5.log('Initializing page visibility tracking.');
+        logger$6.log('Initializing page visibility tracking.');
         this._initScrollDepthTracking();
         var previousTrackedUrl = _.info.currentUrl();
 
@@ -26145,10 +26174,183 @@ define((function () { 'use strict';
         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] = {};
 
@@ -26171,6 +26373,13 @@ define((function () { 'use strict';
         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
@@ -26193,11 +26402,63 @@ define((function () { 'use strict';
         }
 
         this.flags = null;
-        this.fetchFlags();
-
         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() {
@@ -26234,8 +26495,12 @@ define((function () { 'use strict';
         var oldContext = (options && options['replace']) ? {} : this.getConfig(CONFIG_CONTEXT);
         ffConfig[CONFIG_CONTEXT] = _.extend({}, oldContext, newContext);
 
-        this.setMpConfig(FLAGS_CONFIG_KEY, ffConfig);
-        return this.fetchFlags();
+        var configUpdate = {};
+        configUpdate[FLAGS_CONFIG_KEY] = ffConfig;
+        this.setMpConfig(configUpdate);
+        return this.fetchFlags().catch(function() {
+            logger$1.error('Error fetching flags during updateContext');
+        });
     };
 
     FeatureFlagManager.prototype.areFlagsReady = function() {
@@ -26250,12 +26515,11 @@ define((function () { 'use strict';
             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'));
@@ -26272,96 +26536,116 @@ define((function () { 'use strict';
             }
         }).then(function(response) {
             this.markFetchComplete();
-            return response.json().then(function(responseBody) {
-                var responseFlags = responseBody['flags'];
-                if (!responseFlags) {
-                    throw new Error('No flags in API response');
-                }
-                var flags = new Map();
-                var pendingFirstTimeEvents = {};
-
-                // Process flags from response
-                _.each(responseFlags, function(data, key) {
-                    // Check if this flag has any activated first-time events this session
-                    var hasActivatedEvent = false;
-                    var prefix = key + ':';
-                    _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
-                        if (eventKey.startsWith(prefix)) {
-                            hasActivatedEvent = true;
-                        }
-                    });
+            return response.json();
+        }.bind(this)).then(function(responseBody) {
+            var responseFlags = responseBody['flags'];
+            if (!responseFlags) {
+                throw new Error('No flags in API response');
+            }
+            var flags = new Map();
+            var pendingFirstTimeEvents = {};
+
+            // Process flags from response
+            _.each(responseFlags, function(data, key) {
+                // Check if this flag has any activated first-time events this session
+                var hasActivatedEvent = false;
+                var prefix = key + ':';
+                _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
+                    if (eventKey.startsWith(prefix)) {
+                        hasActivatedEvent = true;
+                    }
+                });
 
-                    if (hasActivatedEvent) {
-                        // Preserve the activated variant, don't overwrite with server's current variant
-                        var currentFlag = this.flags && this.flags.get(key);
-                        if (currentFlag) {
-                            flags.set(key, currentFlag);
-                        }
-                    } else {
-                        // Use server's current variant
-                        flags.set(key, {
-                            'key': data['variant_key'],
-                            'value': data['variant_value'],
-                            'experiment_id': data['experiment_id'],
-                            'is_experiment_active': data['is_experiment_active'],
-                            'is_qa_tester': data['is_qa_tester']
-                        });
+                if (hasActivatedEvent) {
+                    // Preserve the activated variant, don't overwrite with server's current variant
+                    var currentFlag = this.flags && this.flags.get(key);
+                    if (currentFlag) {
+                        flags.set(key, currentFlag);
                     }
-                }, this);
+                } else {
+                    // Use server's current variant
+                    flags.set(key, {
+                        'key': data['variant_key'],
+                        'value': data['variant_value'],
+                        'experiment_id': data['experiment_id'],
+                        'is_experiment_active': data['is_experiment_active'],
+                        'is_qa_tester': data['is_qa_tester'],
+                        'variant_source': 'network'
+                    });
+                }
+            }, this);
 
-                // Process top-level pending_first_time_events array
-                var topLevelDefinitions = responseBody['pending_first_time_events'];
-                if (topLevelDefinitions && topLevelDefinitions.length > 0) {
-                    _.each(topLevelDefinitions, function(def) {
-                        var flagKey = def['flag_key'];
-                        var eventKey = getPendingEventKey(flagKey, def['first_time_event_hash']);
+            // Process top-level pending_first_time_events array
+            var topLevelDefinitions = responseBody['pending_first_time_events'];
+            if (topLevelDefinitions && topLevelDefinitions.length > 0) {
+                _.each(topLevelDefinitions, function(def) {
+                    var flagKey = def['flag_key'];
+                    var eventKey = getPendingEventKey(flagKey, def['first_time_event_hash']);
 
-                        // Skip if this specific event has already been activated this session
-                        if (this.activatedFirstTimeEvents[eventKey]) {
-                            return;
-                        }
+                    // Skip if this specific event has already been activated this session
+                    if (this.activatedFirstTimeEvents[eventKey]) {
+                        return;
+                    }
 
-                        // Store pending event definition using composite key
-                        pendingFirstTimeEvents[eventKey] = {
-                            'flag_key': flagKey,
-                            'flag_id': def['flag_id'],
-                            'project_id': def['project_id'],
-                            'first_time_event_hash': def['first_time_event_hash'],
-                            'event_name': def['event_name'],
-                            'property_filters': def['property_filters'],
-                            'pending_variant': def['pending_variant']
-                        };
-                    }, this);
-                }
+                    // Store pending event definition using composite key
+                    pendingFirstTimeEvents[eventKey] = {
+                        'flag_key': flagKey,
+                        'flag_id': def['flag_id'],
+                        'project_id': def['project_id'],
+                        'first_time_event_hash': def['first_time_event_hash'],
+                        'event_name': def['event_name'],
+                        'property_filters': def['property_filters'],
+                        'pending_variant': def['pending_variant']
+                    };
+                }, this);
+            }
 
-                // Preserve any activated orphaned flags (flags that were activated but are no longer in response)
-                if (this.activatedFirstTimeEvents) {
-                    _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
-                        var flagKey = getFlagKeyFromPendingEventKey(eventKey);
-                        if (activated && !flags.has(flagKey) && this.flags && this.flags.has(flagKey)) {
-                            // Keep the activated flag even though it's not in the new response
-                            flags.set(flagKey, this.flags.get(flagKey));
-                        }
-                    }, this);
-                }
+            // Preserve any activated orphaned flags (flags that were activated but are no longer in response)
+            if (this.activatedFirstTimeEvents) {
+                _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
+                    var flagKey = getFlagKeyFromPendingEventKey(eventKey);
+                    if (activated && !flags.has(flagKey) && this.flags && this.flags.has(flagKey)) {
+                        // Keep the activated flag even though it's not in the new response
+                        flags.set(flagKey, this.flags.get(flagKey));
+                    }
+                }, this);
+            }
 
-                this.flags = flags;
-                this.pendingFirstTimeEvents = pendingFirstTimeEvents;
-                this._traceparent = traceparent;
+            this.flags = flags;
+            this.trackedFeatures = new Set();
+            this.pendingFirstTimeEvents = pendingFirstTimeEvents;
+            this._loadedPersistedAtMs = null;
+            this._loadedTtlMs = null;
+            this._traceparent = traceparent;
 
-                this._loadTargetingIfNeeded();
-            }.bind(this)).catch(function(error) {
-                this.markFetchComplete();
-                logger$1.error(error);
-            }.bind(this));
+            this._loadTargetingIfNeeded();
+
+            this.persistence.save(context, this.flags, this.pendingFirstTimeEvents);
         }.bind(this)).catch(function(error) {
-            this.markFetchComplete();
+            if (this._fetchInProgressStartTime) {
+                this.markFetchComplete();
+            }
             logger$1.error(error);
+            throw error;
         }.bind(this));
 
         return this.fetchPromise;
     };
 
+    FeatureFlagManager.prototype.loadFlags = function() {
+        if (!this.isSystemEnabled()) {
+            return Promise.resolve();
+        }
+        if (!this.trackedFeatures) {
+            logger$1.error('loadFlags called before init');
+            return Promise.resolve();
+        }
+        if (this._fetchInProgressStartTime) {
+            return this.fetchPromise;
+        }
+        return this.fetchFlags();
+    };
+
     FeatureFlagManager.prototype.markFetchComplete = function() {
         if (!this._fetchInProgressStartTime) {
             logger$1.error('Fetch in progress started time not set, cannot mark fetch complete');
@@ -26496,6 +26780,7 @@ define((function () { 'use strict';
             };
 
             this.flags.set(flagKey, newVariant);
+            this.trackedFeatures.delete(flagKey);
             this.activatedFirstTimeEvents[eventKey] = true;
 
             this.recordFirstTimeEvent(
@@ -26545,35 +26830,106 @@ define((function () { 'use strict';
     };
 
     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'];
@@ -26612,6 +26968,10 @@ define((function () { 'use strict';
         return val;
     };
 
+    function isPresent(v) {
+        return v !== undefined && v !== null;
+    }
+
     FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature) {
         if (this.trackedFeatures.has(featureName)) {
             return;
@@ -26622,25 +26982,41 @@ define((function () { 'use strict';
             '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);
     };
 
+    FeatureFlagManager.prototype.whenReady = function() {
+        if (this.fetchPromise) {
+            return this.fetchPromise;
+        }
+        return Promise.resolve();
+    };
+
     FeatureFlagManager.prototype.minApisSupported = function() {
         return !!this.fetch &&
           typeof Promise !== 'undefined' &&
@@ -26653,11 +27029,15 @@ define((function () { 'use strict';
     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;
     FeatureFlagManager.prototype['is_enabled_sync'] = FeatureFlagManager.prototype.isEnabledSync;
+    FeatureFlagManager.prototype['load_flags'] = FeatureFlagManager.prototype.loadFlags;
     FeatureFlagManager.prototype['update_context'] = FeatureFlagManager.prototype.updateContext;
+    FeatureFlagManager.prototype['when_ready'] = FeatureFlagManager.prototype.whenReady;
 
     // Deprecated method
     FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
@@ -26703,7 +27083,7 @@ define((function () { 'use strict';
             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 () {
@@ -28630,6 +29010,7 @@ define((function () { 'use strict';
             'disable_all_events': false,
             'identify_called': false
         };
+        this._remote_settings_strict_disabled = false;
 
         // set up request queueing/batching
         this.request_batchers = {};
@@ -28704,9 +29085,6 @@ define((function () { 'use strict';
         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
@@ -28718,6 +29096,9 @@ define((function () { 'use strict';
         } else {
             this.__session_recording_init_promise = this._check_and_start_session_recording();
         }
+
+        this.autocapture = new Autocapture(this);
+        this.autocapture.init();
     };
 
     /**
@@ -28764,9 +29145,19 @@ define((function () { 'use strict';
         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);
@@ -29065,6 +29456,7 @@ define((function () { 'use strict';
         var disableRecordingIfStrict = function() {
             if (mode === 'strict') {
                 self.set_config({'record_sessions_percent': 0});
+                self._remote_settings_strict_disabled = true;
             }
         };
 
@@ -29690,6 +30082,10 @@ define((function () { 'use strict';
             properties
         );
 
+        if (this.is_recording_heatmap_data()) {
+            event_properties['$captured_for_heatmap'] = true;
+        }
+
         return this.track(event_name, event_properties);
     });
 
@@ -30013,7 +30409,9 @@ define((function () { 'use strict';
 
         // check feature flags again if distinct id has changed
         if (new_distinct_id !== previous_distinct_id) {
-            this.flags.fetchFlags();
+            this.flags.fetchFlags().catch(function() {
+                console$1.error('[flags] Error fetching flags during identify');
+            });
         }
     };
 
@@ -30031,6 +30429,7 @@ define((function () { 'use strict';
             '$device_id': uuid
         }, '');
         this._check_and_start_session_recording();
+        this.flags.reset();
     };
 
     /**