mixpanel-browser 2.67.0 → 2.69.0

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+**2.68.0** (11 Aug 2025)
+- Initial rage-click detection support
+- Block `<audio>` tags by default in Session Recording
+- Add `flags.update_context()` method for updating context variables and refetching variants
+
 **2.67.0** (17 Jul 2025)
 - Use `get_api_host()` consistently across the SDK
 - Include `device_id` in default Feature Flag context

package/dist/mixpanel-core.cjs.js

@@ -2,7 +2,7 @@
 
 var Config = {
     DEBUG: false,
-    LIB_VERSION: '2.67.0'
+    LIB_VERSION: '2.69.0'
 };
 
 // since es6 imports are static and we run unit tests from the console, window won't be defined when importing this file
@@ -2654,6 +2654,38 @@ function shouldTrackValue(value) {
     return true;
 }
 
+/** @const */ var DEFAULT_RAGE_CLICK_THRESHOLD_PX = 30;
+/** @const */ var DEFAULT_RAGE_CLICK_TIMEOUT_MS = 1000;
+/** @const */ var DEFAULT_RAGE_CLICK_CLICK_COUNT = 4;
+
+function RageClickTracker() {
+    this.clicks = [];
+}
+
+RageClickTracker.prototype.isRageClick = function(x, y, options) {
+    options = options || {};
+    var thresholdPx = options['threshold_px'] || DEFAULT_RAGE_CLICK_THRESHOLD_PX;
+    var timeoutMs = options['timeout_ms'] || DEFAULT_RAGE_CLICK_TIMEOUT_MS;
+    var clickCount = options['click_count'] || DEFAULT_RAGE_CLICK_CLICK_COUNT;
+    var timestamp = Date.now();
+
+    var lastClick = this.clicks[this.clicks.length - 1];
+    if (
+        lastClick &&
+        timestamp - lastClick.timestamp < timeoutMs &&
+        Math.sqrt(Math.pow(x - lastClick.x, 2) + Math.pow(y - lastClick.y, 2)) < thresholdPx
+    ) {
+        this.clicks.push({ x: x, y: y, timestamp: timestamp });
+        if (this.clicks.length >= clickCount) {
+            this.clicks = [];
+            return true;
+        }
+    } else {
+        this.clicks = [{ x: x, y: y, timestamp: timestamp }];
+    }
+    return false;
+};
+
 var AUTOCAPTURE_CONFIG_KEY = 'autocapture';
 var LEGACY_PAGEVIEW_CONFIG_KEY = 'track_pageview';
 
@@ -2675,6 +2707,7 @@ var CONFIG_SCROLL_CHECKPOINTS = 'scroll_depth_percent_checkpoints';
 var CONFIG_TRACK_CLICK = 'click';
 var CONFIG_TRACK_INPUT = 'input';
 var CONFIG_TRACK_PAGEVIEW = 'pageview';
+var CONFIG_TRACK_RAGE_CLICK = 'rage_click';
 var CONFIG_TRACK_SCROLL = 'scroll';
 var CONFIG_TRACK_SUBMIT = 'submit';
 
@@ -2692,6 +2725,7 @@ CONFIG_DEFAULTS$1[CONFIG_SCROLL_CHECKPOINTS] = [25, 50, 75, 100];
 CONFIG_DEFAULTS$1[CONFIG_TRACK_CLICK] = true;
 CONFIG_DEFAULTS$1[CONFIG_TRACK_INPUT] = true;
 CONFIG_DEFAULTS$1[CONFIG_TRACK_PAGEVIEW] = PAGEVIEW_OPTION_FULL_URL;
+CONFIG_DEFAULTS$1[CONFIG_TRACK_RAGE_CLICK] = true;
 CONFIG_DEFAULTS$1[CONFIG_TRACK_SCROLL] = true;
 CONFIG_DEFAULTS$1[CONFIG_TRACK_SUBMIT] = true;
 
@@ -2701,6 +2735,7 @@ var DEFAULT_PROPS = {
 
 var MP_EV_CLICK = '$mp_click';
 var MP_EV_INPUT = '$mp_input_change';
+var MP_EV_RAGE_CLICK = '$mp_rage_click';
 var MP_EV_SCROLL = '$mp_scroll';
 var MP_EV_SUBMIT = '$mp_submit';
 
@@ -2723,6 +2758,7 @@ Autocapture.prototype.init = function() {
     this.initInputTracking();
     this.initScrollTracking();
     this.initSubmitTracking();
+    this.initRageClickTracking();
 };
 
 Autocapture.prototype.getFullConfig = function() {
@@ -2801,6 +2837,11 @@ Autocapture.prototype.trackDomEvent = function(ev, mpEventName) {
         return;
     }
 
+    var isCapturedForHeatMap = this.mp.is_recording_heatmap_data() && (
+        (mpEventName === MP_EV_CLICK && !this.getConfig(CONFIG_TRACK_CLICK)) ||
+        (mpEventName === MP_EV_RAGE_CLICK && !this._getRageClickConfig())
+    );
+
     var props = getPropsForDOMEvent(ev, {
         allowElementCallback: this.getConfig(CONFIG_ALLOW_ELEMENT_CALLBACK),
         allowSelectors: this.getConfig(CONFIG_ALLOW_SELECTORS),
@@ -2809,7 +2850,7 @@ Autocapture.prototype.trackDomEvent = function(ev, mpEventName) {
         blockSelectors: this.getConfig(CONFIG_BLOCK_SELECTORS),
         captureExtraAttrs: this.getConfig(CONFIG_CAPTURE_EXTRA_ATTRS),
         captureTextContent: this.getConfig(CONFIG_CAPTURE_TEXT_CONTENT),
-        capturedForHeatMap: mpEventName === MP_EV_CLICK && !this.getConfig(CONFIG_TRACK_CLICK) && this.mp.is_recording_heatmap_data(),
+        capturedForHeatMap: isCapturedForHeatMap,
     });
     if (props) {
         _.extend(props, DEFAULT_PROPS);
@@ -2817,6 +2858,24 @@ Autocapture.prototype.trackDomEvent = function(ev, mpEventName) {
     }
 };
 
+Autocapture.prototype._getRageClickConfig = function() {
+    var config = this.getConfig(CONFIG_TRACK_RAGE_CLICK);
+
+    if (!config) {
+        return null; // rage click tracking disabled
+    }
+
+    if (config === true) {
+        return {}; // use defaults
+    }
+
+    if (typeof config === 'object') {
+        return config; // use custom configuration
+    }
+
+    return {}; // fallback to defaults for any other truthy value
+};
+
 Autocapture.prototype.initClickTracking = function() {
     win.removeEventListener(EV_CLICK, this.listenerClick);
 
@@ -2918,6 +2977,36 @@ Autocapture.prototype.initPageviewTracking = function() {
     }.bind(this)));
 };
 
+Autocapture.prototype.initRageClickTracking = function() {
+    win.removeEventListener(EV_CLICK, this.listenerRageClick);
+
+    var rageClickConfig = this._getRageClickConfig();
+    if (!rageClickConfig && !this.mp.get_config('record_heatmap_data')) {
+        return;
+    }
+
+    logger$4.log('Initializing rage click tracking');
+    if (!this._rageClickTracker) {
+        this._rageClickTracker = new RageClickTracker();
+    }
+
+    this.listenerRageClick = function(ev) {
+        var currentRageClickConfig = this._getRageClickConfig();
+        if (!currentRageClickConfig && !this.mp.is_recording_heatmap_data()) {
+            return;
+        }
+
+        if (this.currentUrlBlocked()) {
+            return;
+        }
+
+        if (this._rageClickTracker.isRageClick(ev['pageX'], ev['pageY'], currentRageClickConfig)) {
+            this.trackDomEvent(ev, MP_EV_RAGE_CLICK);
+        }
+    }.bind(this);
+    win.addEventListener(EV_CLICK, this.listenerRageClick);
+};
+
 Autocapture.prototype.initScrollTracking = function() {
     win.removeEventListener(EV_SCROLLEND, this.listenerScroll);
 
@@ -3004,6 +3093,7 @@ CONFIG_DEFAULTS[CONFIG_CONTEXT] = {};
 var FeatureFlagManager = function(initOptions) {
     this.getFullApiRoute = initOptions.getFullApiRoute;
     this.getMpConfig = initOptions.getConfigFunc;
+    this.setMpConfig = initOptions.setConfigFunc;
     this.getMpProperty = initOptions.getPropertyFunc;
     this.track = initOptions.trackingFunc;
 };
@@ -3041,6 +3131,23 @@ FeatureFlagManager.prototype.isSystemEnabled = function() {
     return !!this.getMpConfig(FLAGS_CONFIG_KEY);
 };
 
+FeatureFlagManager.prototype.updateContext = function(newContext, options) {
+    if (!this.isSystemEnabled()) {
+        logger$3.critical('Feature Flags not enabled, cannot update context');
+        return Promise.resolve();
+    }
+
+    var ffConfig = this.getMpConfig(FLAGS_CONFIG_KEY);
+    if (!_.isObject(ffConfig)) {
+        ffConfig = {};
+    }
+    var oldContext = (options && options['replace']) ? {} : this.getConfig(CONFIG_CONTEXT);
+    ffConfig[CONFIG_CONTEXT] = _.extend({}, oldContext, newContext);
+
+    this.setMpConfig(FLAGS_CONFIG_KEY, ffConfig);
+    return this.fetchFlags();
+};
+
 FeatureFlagManager.prototype.areFlagsReady = function() {
     if (!this.isSystemEnabled()) {
         logger$3.error('Feature Flags not enabled');
@@ -3050,7 +3157,7 @@ FeatureFlagManager.prototype.areFlagsReady = function() {
 
 FeatureFlagManager.prototype.fetchFlags = function() {
     if (!this.isSystemEnabled()) {
-        return;
+        return Promise.resolve();
     }
 
     var distinctId = this.getMpProperty('distinct_id');
@@ -3090,6 +3197,8 @@ FeatureFlagManager.prototype.fetchFlags = function() {
         this.markFetchComplete();
         logger$3.error(error);
     }.bind(this));
+
+    return this.fetchPromise;
 };
 
 FeatureFlagManager.prototype.markFetchComplete = function() {
@@ -3202,6 +3311,7 @@ FeatureFlagManager.prototype['get_variant_value'] = FeatureFlagManager.prototype
 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['update_context'] = FeatureFlagManager.prototype.updateContext;
 
 // Deprecated method
 FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
@@ -3519,6 +3629,10 @@ LocalStorageWrapper.prototype.init = function () {
     return PromisePolyfill.resolve();
 };
 
+LocalStorageWrapper.prototype.isInitialized = function () {
+    return true;
+};
+
 LocalStorageWrapper.prototype.setItem = function (key, value) {
     return new PromisePolyfill(_.bind(function (resolve, reject) {
         try {
@@ -3599,7 +3713,7 @@ var RequestQueue = function (storageKey, options) {
 };
 
 RequestQueue.prototype.ensureInit = function () {
-    if (this.initialized) {
+    if (this.initialized || !this.usePersistence) {
         return PromisePolyfill.resolve();
     }
 
@@ -5783,6 +5897,10 @@ IDBStorageWrapper.prototype.init = function () {
         });
 };
 
+IDBStorageWrapper.prototype.isInitialized = function () {
+    return !!this.dbPromise;
+};
+
 /**
  * @param {IDBTransactionMode} mode
  * @param {function(IDBObjectStore): void} storeCb
@@ -5973,7 +6091,7 @@ var DEFAULT_CONFIG = {
     'batch_autostart':                   true,
     'hooks':                             {},
     'record_block_class':                new RegExp('^(mp-block|fs-exclude|amp-block|rr-block|ph-no-capture)$'),
-    'record_block_selector':             'img, video',
+    'record_block_selector':             'img, video, audio',
     'record_canvas':                     false,
     'record_collect_fonts':              false,
     'record_heatmap_data':               false,
@@ -6197,6 +6315,7 @@ MixpanelLib.prototype._init = function(token, config, name) {
             return this.get_api_host('flags') + '/' + this.get_config('api_routes')['flags'];
         }, this),
         getConfigFunc: _.bind(this.get_config, this),
+        setConfigFunc: _.bind(this.set_config, this),
         getPropertyFunc: _.bind(this.get_property, this),
         trackingFunc: _.bind(this.track, this)
     });
@@ -6215,7 +6334,9 @@ MixpanelLib.prototype._init = function(token, config, name) {
  * This is primarily used for session recording, where data must be isolated to the current tab.
  */
 MixpanelLib.prototype._init_tab_id = function() {
-    if (_.sessionStorage.is_supported()) {
+    if (this.get_config('disable_persistence')) {
+        console.log('Tab ID initialization skipped due to disable_persistence config');
+    } else if (_.sessionStorage.is_supported()) {
         try {
             var key_suffix = this.get_config('name') + '_' + this.get_config('token');
             var tab_id_key = 'mp_tab_id_' + key_suffix;
@@ -6249,6 +6370,11 @@ MixpanelLib.prototype.get_tab_id = function () {
 };
 
 MixpanelLib.prototype._should_load_recorder = function () {
+    if (this.get_config('disable_persistence')) {
+        console.log('Load recorder check skipped due to disable_persistence config');
+        return Promise.resolve(false);
+    }
+
     var recording_registry_idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
     var tab_id = this.get_tab_id();
     return recording_registry_idb.init()

package/dist/mixpanel-recorder.js

@@ -486,6 +486,30 @@
     function mutationObserverCtor$1() {
         return getUntaintedPrototype$1("MutationObserver").constructor;
     }
+    function patch$1(source, name, replacement) {
+        try {
+            if (!(name in source)) {
+                return function() {};
+            }
+            var original = source[name];
+            var wrapped = replacement(original);
+            if (typeof wrapped === "function") {
+                wrapped.prototype = wrapped.prototype || {};
+                Object.defineProperties(wrapped, {
+                    __rrweb_original__: {
+                        enumerable: false,
+                        value: original
+                    }
+                });
+            }
+            source[name] = wrapped;
+            return function() {
+                source[name] = original;
+            };
+        } catch (e) {
+            return function() {};
+        }
+    }
     var index$1 = {
         childNodes: childNodes$1,
         parentNode: parentNode$1,
@@ -498,7 +522,8 @@
         shadowRoot: shadowRoot$1,
         querySelector: querySelector$1,
         querySelectorAll: querySelectorAll$1,
-        mutationObserver: mutationObserverCtor$1
+        mutationObserver: mutationObserverCtor$1,
+        patch: patch$1
     };
     function isElement(n2) {
         return n2.nodeType === n2.ELEMENT_NODE;
@@ -749,26 +774,82 @@
             return "url(" + maybeQuote + stack.join("/") + maybeQuote + ")";
         });
     }
-    function normalizeCssString(cssText) {
-        return cssText.replace(/(\/\*[^*]*\*\/)|[\s;]/g, "");
+    function normalizeCssString(cssText, _testNoPxNorm) {
+        if (_testNoPxNorm === void 0) _testNoPxNorm = false;
+        if (_testNoPxNorm) {
+            return cssText.replace(/(\/\*[^*]*\*\/)|[\s;]/g, "");
+        } else {
+            return cssText.replace(/(\/\*[^*]*\*\/)|[\s;]/g, "").replace(/0px/g, "0");
+        }
     }
-    function splitCssText(cssText, style) {
+    function splitCssText(cssText, style, _testNoPxNorm) {
+        if (_testNoPxNorm === void 0) _testNoPxNorm = false;
         var childNodes2 = Array.from(style.childNodes);
         var splits = [];
+        var iterCount = 0;
         if (childNodes2.length > 1 && cssText && typeof cssText === "string") {
-            var cssTextNorm = normalizeCssString(cssText);
+            var cssTextNorm = normalizeCssString(cssText, _testNoPxNorm);
+            var normFactor = cssTextNorm.length / cssText.length;
             for(var i2 = 1; i2 < childNodes2.length; i2++){
                 if (childNodes2[i2].textContent && typeof childNodes2[i2].textContent === "string") {
-                    var textContentNorm = normalizeCssString(childNodes2[i2].textContent);
-                    for(var j = 3; j < textContentNorm.length; j++){
-                        var bit = textContentNorm.substring(0, j);
-                        if (cssTextNorm.split(bit).length === 2) {
-                            var splitNorm = cssTextNorm.indexOf(bit);
-                            for(var k = splitNorm; k < cssText.length; k++){
-                                if (normalizeCssString(cssText.substring(0, k)).length === splitNorm) {
+                    var textContentNorm = normalizeCssString(childNodes2[i2].textContent, _testNoPxNorm);
+                    var jLimit = 100;
+                    var j = 3;
+                    for(; j < textContentNorm.length; j++){
+                        if (// keep consuming css identifiers (to get a decent chunk more quickly)
+                        textContentNorm[j].match(/[a-zA-Z0-9]/) || // substring needs to be unique to this section
+                        textContentNorm.indexOf(textContentNorm.substring(0, j), 1) !== -1) {
+                            continue;
+                        }
+                        break;
+                    }
+                    for(; j < textContentNorm.length; j++){
+                        var startSubstring = textContentNorm.substring(0, j);
+                        var cssNormSplits = cssTextNorm.split(startSubstring);
+                        var splitNorm = -1;
+                        if (cssNormSplits.length === 2) {
+                            splitNorm = cssNormSplits[0].length;
+                        } else if (cssNormSplits.length > 2 && cssNormSplits[0] === "" && childNodes2[i2 - 1].textContent !== "") {
+                            splitNorm = cssTextNorm.indexOf(startSubstring, 1);
+                        } else if (cssNormSplits.length === 1) {
+                            startSubstring = startSubstring.substring(0, startSubstring.length - 1);
+                            cssNormSplits = cssTextNorm.split(startSubstring);
+                            if (cssNormSplits.length <= 1) {
+                                splits.push(cssText);
+                                return splits;
+                            }
+                            j = jLimit + 1;
+                        } else if (j === textContentNorm.length - 1) {
+                            splitNorm = cssTextNorm.indexOf(startSubstring);
+                        }
+                        if (cssNormSplits.length >= 2 && j > jLimit) {
+                            var prevTextContent = childNodes2[i2 - 1].textContent;
+                            if (prevTextContent && typeof prevTextContent === "string") {
+                                var prevMinLength = normalizeCssString(prevTextContent).length;
+                                splitNorm = cssTextNorm.indexOf(startSubstring, prevMinLength);
+                            }
+                            if (splitNorm === -1) {
+                                splitNorm = cssNormSplits[0].length;
+                            }
+                        }
+                        if (splitNorm !== -1) {
+                            var k = Math.floor(splitNorm / normFactor);
+                            for(; k > 0 && k < cssText.length;){
+                                iterCount += 1;
+                                if (iterCount > 50 * childNodes2.length) {
+                                    splits.push(cssText);
+                                    return splits;
+                                }
+                                var normPart = normalizeCssString(cssText.substring(0, k), _testNoPxNorm);
+                                if (normPart.length === splitNorm) {
                                     splits.push(cssText.substring(0, k));
                                     cssText = cssText.substring(k);
+                                    cssTextNorm = cssTextNorm.substring(splitNorm);
                                     break;
+                                } else if (normPart.length < splitNorm) {
+                                    k += Math.max(1, Math.floor((splitNorm - normPart.length) / normFactor));
+                                } else {
+                                    k -= Math.max(1, Math.floor((normPart.length - splitNorm) * normFactor));
                                 }
                             }
                             break;
@@ -1285,7 +1366,7 @@
         } else if (sn.type === NodeType$3.Element) {
             if (slimDOMOptions.script && // script tag
             (sn.tagName === "script" || // (module)preload link
-            sn.tagName === "link" && (sn.attributes.rel === "preload" || sn.attributes.rel === "modulepreload") && sn.attributes.as === "script" || // prefetch link
+            sn.tagName === "link" && (sn.attributes.rel === "preload" && sn.attributes.as === "script" || sn.attributes.rel === "modulepreload") || // prefetch link
             sn.tagName === "link" && sn.attributes.rel === "prefetch" && typeof sn.attributes.href === "string" && extractFileExtension(sn.attributes.href) === "js")) {
                 return true;
             } else if (slimDOMOptions.headFavicon && (sn.tagName === "link" && sn.attributes.rel === "shortcut icon" || sn.tagName === "meta" && (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) || lowerIfExists(sn.attributes.name) === "application-name" || lowerIfExists(sn.attributes.rel) === "icon" || lowerIfExists(sn.attributes.rel) === "apple-touch-icon" || lowerIfExists(sn.attributes.rel) === "shortcut icon"))) {
@@ -10036,6 +10117,30 @@
     function mutationObserverCtor() {
         return getUntaintedPrototype("MutationObserver").constructor;
     }
+    function patch(source, name, replacement) {
+        try {
+            if (!(name in source)) {
+                return function() {};
+            }
+            var original = source[name];
+            var wrapped = replacement(original);
+            if (typeof wrapped === "function") {
+                wrapped.prototype = wrapped.prototype || {};
+                Object.defineProperties(wrapped, {
+                    __rrweb_original__: {
+                        enumerable: false,
+                        value: original
+                    }
+                });
+            }
+            source[name] = wrapped;
+            return function() {
+                source[name] = original;
+            };
+        } catch (e) {
+            return function() {};
+        }
+    }
     var index = {
         childNodes: childNodes,
         parentNode: parentNode,
@@ -10048,7 +10153,8 @@
         shadowRoot: shadowRoot,
         querySelector: querySelector,
         querySelectorAll: querySelectorAll,
-        mutationObserver: mutationObserverCtor
+        mutationObserver: mutationObserverCtor,
+        patch: patch
     };
     function on(type, fn, target) {
         if (target === void 0) target = document;
@@ -10141,30 +10247,6 @@
             return hookSetter(target, key, original || {}, true);
         };
     }
-    function patch(source, name, replacement) {
-        try {
-            if (!(name in source)) {
-                return function() {};
-            }
-            var original = source[name];
-            var wrapped = replacement(original);
-            if (typeof wrapped === "function") {
-                wrapped.prototype = wrapped.prototype || {};
-                Object.defineProperties(wrapped, {
-                    __rrweb_original__: {
-                        enumerable: false,
-                        value: original
-                    }
-                });
-            }
-            source[name] = wrapped;
-            return function() {
-                source[name] = original;
-            };
-        } catch (e) {
-            return function() {};
-        }
-    }
     var nowTimestamp = Date.now;
     if (!/* @__PURE__ */ /[1-9][0-9]{12}/.test(Date.now().toString())) {
         nowTimestamp = function() {
@@ -10755,9 +10837,17 @@
                     _this.attributes.push(item);
                     _this.attributeMap.set(textarea, item);
                 }
-                item.attributes.value = Array.from(index.childNodes(textarea), function(cn) {
+                var value = Array.from(index.childNodes(textarea), function(cn) {
                     return index.textContent(cn) || "";
                 }).join("");
+                item.attributes.value = maskInputValue({
+                    element: textarea,
+                    maskInputOptions: _this.maskInputOptions,
+                    tagName: textarea.tagName,
+                    type: getInputType(textarea),
+                    value: value,
+                    maskInputFn: _this.maskInputFn
+                });
             });
             __publicField(this, "processMutation", function(m) {
                 if (isIgnored(m.target, _this.mirror, _this.slimDOMOptions)) {
@@ -13538,8 +13628,15 @@
                 }, window));
             }
             return function() {
-                handlers.forEach(function(h) {
-                    return h();
+                handlers.forEach(function(handler) {
+                    try {
+                        handler();
+                    } catch (error) {
+                        var msg = String(error).toLowerCase();
+                        if (!msg.includes("cross-origin")) {
+                            console.warn(error);
+                        }
+                    }
                 });
                 processedNodeManager.destroy();
                 recording = false;
@@ -13944,7 +14041,7 @@
     }
 
     var Config = {
-        LIB_VERSION: '2.67.0'
+        LIB_VERSION: '2.69.0'
     };
 
     /* eslint camelcase: "off", eqeqeq: "off" */
@@ -15692,6 +15789,10 @@
             });
     };
 
+    IDBStorageWrapper.prototype.isInitialized = function () {
+        return !!this.dbPromise;
+    };
+
     /**
      * @param {IDBTransactionMode} mode
      * @param {function(IDBObjectStore): void} storeCb
@@ -16084,6 +16185,10 @@
         return PromisePolyfill.resolve();
     };
 
+    LocalStorageWrapper.prototype.isInitialized = function () {
+        return true;
+    };
+
     LocalStorageWrapper.prototype.setItem = function (key, value) {
         return new PromisePolyfill(_.bind(function (resolve, reject) {
             try {
@@ -16164,7 +16269,7 @@
     };
 
     RequestQueue.prototype.ensureInit = function () {
-        if (this.initialized) {
+        if (this.initialized || !this.usePersistence) {
             return PromisePolyfill.resolve();
         }
 
@@ -16916,10 +17021,9 @@
 
         // disable persistence if localStorage is not supported
         // request-queue will automatically disable persistence if indexedDB fails to initialize
-        var usePersistence = localStorageSupported(options.sharedLockStorage, true);
+        var usePersistence = localStorageSupported(options.sharedLockStorage, true) && !this.getConfig('disable_persistence');
 
         // each replay has its own batcher key to avoid conflicts between rrweb events of different recordings
-        // this will be important when persistence is introduced
         this.batcherKey = '__mprec_' + this.getConfig('name') + '_' + this.getConfig('token') + '_' + this.replayId;
         this.queueStorage = new IDBStorageWrapper(RECORDING_EVENTS_STORE_NAME);
         this.batcher = new RequestBatcher(this.batcherKey, {
@@ -17300,12 +17404,17 @@
      * Makes sure that only one tab can be recording at a time.
      */
     var RecordingRegistry = function (options) {
+        /** @type {IDBStorageWrapper} */
         this.idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
         this.errorReporter = options.errorReporter;
         this.mixpanelInstance = options.mixpanelInstance;
         this.sharedLockStorage = options.sharedLockStorage;
     };
 
+    RecordingRegistry.prototype.isPersistenceEnabled = function() {
+        return !this.mixpanelInstance.get_config('disable_persistence');
+    };
+
     RecordingRegistry.prototype.handleError = function (err) {
         this.errorReporter('IndexedDB error: ', err);
     };
@@ -17314,6 +17423,10 @@
      * @param {import('./session-recording').SerializedRecording} serializedRecording
      */
     RecordingRegistry.prototype.setActiveRecording = function (serializedRecording) {
+        if (!this.isPersistenceEnabled()) {
+            return PromisePolyfill.resolve();
+        }
+
         var tabId = serializedRecording['tabId'];
         if (!tabId) {
             console.warn('No tab ID is set, cannot persist recording metadata.');
@@ -17331,6 +17444,10 @@
      * @returns {Promise<import('./session-recording').SerializedRecording>}
      */
     RecordingRegistry.prototype.getActiveRecording = function () {
+        if (!this.isPersistenceEnabled()) {
+            return PromisePolyfill.resolve(null);
+        }
+
         return this.idb.init()
             .then(function () {
                 return this.idb.getItem(this.mixpanelInstance.get_tab_id());
@@ -17342,8 +17459,16 @@
     };
 
     RecordingRegistry.prototype.clearActiveRecording = function () {
-        // mark recording as expired instead of deleting it in case the page unloads mid-flush and doesn't make it to ingestion.
-        // this will ensure the next pageload will flush the remaining events, but not try to continue the recording.
+        if (this.isPersistenceEnabled()) {
+            // mark recording as expired instead of deleting it in case the page unloads mid-flush and doesn't make it to ingestion.
+            // this will ensure the next pageload will flush the remaining events, but not try to continue the recording.
+            return this.markActiveRecordingExpired();
+        } else {
+            return this.deleteActiveRecording();
+        }
+    };
+
+    RecordingRegistry.prototype.markActiveRecordingExpired = function () {
         return this.getActiveRecording()
             .then(function (serializedRecording) {
                 if (serializedRecording) {
@@ -17354,11 +17479,25 @@
             .catch(this.handleError.bind(this));
     };
 
+    RecordingRegistry.prototype.deleteActiveRecording = function () {
+        // avoid initializing IDB if this registry instance hasn't already written a recording
+        if (this.idb.isInitialized()) {
+            return this.idb.removeItem(this.mixpanelInstance.get_tab_id())
+                .catch(this.handleError.bind(this));
+        } else {
+            return PromisePolyfill.resolve();
+        }
+    };
+
     /**
      * Flush any inactive recordings from the registry to minimize data loss.
      * The main idea here is that we can flush remaining rrweb events on the next page load if a tab is closed mid-batch.
      */
     RecordingRegistry.prototype.flushInactiveRecordings = function () {
+        if (!this.isPersistenceEnabled()) {
+            return PromisePolyfill.resolve([]);
+        }
+
         return this.idb.init()
             .then(function() {
                 return this.idb.getAll();