mixpanel-browser 2.75.0 → 2.77.0

package/dist/mixpanel.umd.js

@@ -29,16 +29,19 @@
         win = window;
     }
 
-    /**
-     * Shared global window property names used across modules
-     */
+    var Config = {
+        DEBUG: false,
+        LIB_VERSION: '2.77.0'
+    };
 
-    // Targeting library global (used by flags and targeting modules)
+    // Window global names for async modules
     var TARGETING_GLOBAL_NAME = '__mp_targeting';
-
-    // Recorder library global (used by recorder and mixpanel-core)
     var RECORDER_GLOBAL_NAME = '__mp_recorder';
 
+    // Constants that are injected at build-time for the names of async modules.
+    var RECORDER_FILENAME = '__MP_RECORDER_FILENAME__';
+    var TARGETING_FILENAME = '__MP_TARGETING_FILENAME__';
+
     function _array_like_to_array(arr, len) {
         if (len == null || len > arr.length) len = arr.length;
         for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -10736,13 +10739,7 @@
                 };
                 while(_this.mapRemoves.length){
                     var removedNode = _this.mapRemoves.shift();
-                    if (removedNode.nodeName === "IFRAME") {
-                        try {
-                            _this.iframeManager.removeIframe(removedNode);
-                        } catch (e2) {}
-                    } else {
-                        _this.stylesheetManager.cleanupStylesheetsForRemovedNode(removedNode);
-                    }
+                    _this.cleanupRemovedNode(removedNode);
                     _this.mirror.removeNodeFromMap(removedNode);
                 }
                 for(var _iterator = _create_for_of_iterator_helper_loose(_this.movedSet), _step; !(_step = _iterator()).done;){
@@ -11062,6 +11059,20 @@
                     }
                 }
             });
+            __publicField$1(this, "cleanupRemovedNode", function(node2) {
+                if (node2.nodeName === "IFRAME") {
+                    try {
+                        _this.iframeManager.removeIframe(node2);
+                    } catch (e2) {}
+                } else {
+                    try {
+                        _this.stylesheetManager.cleanupStylesheetsForRemovedNode(node2);
+                    } catch (e2) {}
+                }
+                node2.childNodes.forEach(function(child) {
+                    _this.cleanupRemovedNode(child);
+                });
+            });
         }
         var _proto = MutationBuffer.prototype;
         _proto.init = function init(options) {
@@ -13289,6 +13300,31 @@
         _proto.destroy = function destroy() {};
         return ProcessedNodeManager;
     }();
+    function toOrigin(url) {
+        try {
+            var origin = new URL(url).origin;
+            return origin !== "null" ? origin : null;
+        } catch (e) {
+            return null;
+        }
+    }
+    function buildAllowedOriginSet(origins) {
+        if (!Array.isArray(origins) || origins.length === 0) {
+            throw new Error("[rrweb] allowedIframeOrigins must be a non-empty array of origin strings.");
+        }
+        var set = /* @__PURE__ */ new Set();
+        for(var i2 = 0; i2 < origins.length; i2++){
+            var entry = origins[i2];
+            if (typeof entry !== "string") {
+                throw new Error("[rrweb] allowedIframeOrigins[" + i2 + "] must be a string, got " + (typeof entry === "undefined" ? "undefined" : _type_of(entry)) + ".");
+            }
+            var origin = toOrigin(entry);
+            if (origin) {
+                set.add(origin);
+            }
+        }
+        return Object.freeze(set);
+    }
     var wrappedEmit;
     var takeFullSnapshot$1;
     var canvasManager;
@@ -13310,10 +13346,17 @@
     var mirror = createMirror$2();
     function record(options) {
         if (options === void 0) options = {};
-        var emit = options.emit, checkoutEveryNms = options.checkoutEveryNms, checkoutEveryNth = options.checkoutEveryNth, _options_blockClass = options.blockClass, blockClass = _options_blockClass === void 0 ? "rr-block" : _options_blockClass, _options_blockSelector = options.blockSelector, blockSelector = _options_blockSelector === void 0 ? null : _options_blockSelector, _options_ignoreClass = options.ignoreClass, ignoreClass = _options_ignoreClass === void 0 ? "rr-ignore" : _options_ignoreClass, _options_ignoreSelector = options.ignoreSelector, ignoreSelector = _options_ignoreSelector === void 0 ? null : _options_ignoreSelector, _options_maskTextClass = options.maskTextClass, maskTextClass = _options_maskTextClass === void 0 ? "rr-mask" : _options_maskTextClass, _options_maskTextSelector = options.maskTextSelector, maskTextSelector = _options_maskTextSelector === void 0 ? null : _options_maskTextSelector, _options_inlineStylesheet = options.inlineStylesheet, inlineStylesheet = _options_inlineStylesheet === void 0 ? true : _options_inlineStylesheet, maskAllInputs = options.maskAllInputs, _maskInputOptions = options.maskInputOptions, _slimDOMOptions = options.slimDOMOptions, maskInputFn = options.maskInputFn, maskTextFn = options.maskTextFn, hooks = options.hooks, packFn = options.packFn, _options_sampling = options.sampling, sampling = _options_sampling === void 0 ? {} : _options_sampling, _options_dataURLOptions = options.dataURLOptions, dataURLOptions = _options_dataURLOptions === void 0 ? {} : _options_dataURLOptions, mousemoveWait = options.mousemoveWait, _options_recordDOM = options.recordDOM, recordDOM = _options_recordDOM === void 0 ? true : _options_recordDOM, _options_recordCanvas = options.recordCanvas, recordCanvas = _options_recordCanvas === void 0 ? false : _options_recordCanvas, _options_recordCrossOriginIframes = options.recordCrossOriginIframes, recordCrossOriginIframes = _options_recordCrossOriginIframes === void 0 ? false : _options_recordCrossOriginIframes, _options_recordAfter = options.recordAfter, recordAfter = _options_recordAfter === void 0 ? options.recordAfter === "DOMContentLoaded" ? options.recordAfter : "load" : _options_recordAfter, _options_userTriggeredOnInput = options.userTriggeredOnInput, userTriggeredOnInput = _options_userTriggeredOnInput === void 0 ? false : _options_userTriggeredOnInput, _options_collectFonts = options.collectFonts, collectFonts = _options_collectFonts === void 0 ? false : _options_collectFonts, _options_inlineImages = options.inlineImages, inlineImages = _options_inlineImages === void 0 ? false : _options_inlineImages, plugins = options.plugins, _options_keepIframeSrcFn = options.keepIframeSrcFn, keepIframeSrcFn = _options_keepIframeSrcFn === void 0 ? function() {
+        var emit = options.emit, checkoutEveryNms = options.checkoutEveryNms, checkoutEveryNth = options.checkoutEveryNth, _options_blockClass = options.blockClass, blockClass = _options_blockClass === void 0 ? "rr-block" : _options_blockClass, _options_blockSelector = options.blockSelector, blockSelector = _options_blockSelector === void 0 ? null : _options_blockSelector, _options_ignoreClass = options.ignoreClass, ignoreClass = _options_ignoreClass === void 0 ? "rr-ignore" : _options_ignoreClass, _options_ignoreSelector = options.ignoreSelector, ignoreSelector = _options_ignoreSelector === void 0 ? null : _options_ignoreSelector, _options_maskTextClass = options.maskTextClass, maskTextClass = _options_maskTextClass === void 0 ? "rr-mask" : _options_maskTextClass, _options_maskTextSelector = options.maskTextSelector, maskTextSelector = _options_maskTextSelector === void 0 ? null : _options_maskTextSelector, _options_inlineStylesheet = options.inlineStylesheet, inlineStylesheet = _options_inlineStylesheet === void 0 ? true : _options_inlineStylesheet, maskAllInputs = options.maskAllInputs, _maskInputOptions = options.maskInputOptions, _slimDOMOptions = options.slimDOMOptions, maskInputFn = options.maskInputFn, maskTextFn = options.maskTextFn, hooks = options.hooks, packFn = options.packFn, _options_sampling = options.sampling, sampling = _options_sampling === void 0 ? {} : _options_sampling, _options_dataURLOptions = options.dataURLOptions, dataURLOptions = _options_dataURLOptions === void 0 ? {} : _options_dataURLOptions, mousemoveWait = options.mousemoveWait, _options_recordDOM = options.recordDOM, recordDOM = _options_recordDOM === void 0 ? true : _options_recordDOM, _options_recordCanvas = options.recordCanvas, recordCanvas = _options_recordCanvas === void 0 ? false : _options_recordCanvas, _options_recordCrossOriginIframes = options.recordCrossOriginIframes, recordCrossOriginIframes = _options_recordCrossOriginIframes === void 0 ? false : _options_recordCrossOriginIframes, allowedIframeOrigins = options.allowedIframeOrigins, _options_recordAfter = options.recordAfter, recordAfter = _options_recordAfter === void 0 ? options.recordAfter === "DOMContentLoaded" ? options.recordAfter : "load" : _options_recordAfter, _options_userTriggeredOnInput = options.userTriggeredOnInput, userTriggeredOnInput = _options_userTriggeredOnInput === void 0 ? false : _options_userTriggeredOnInput, _options_collectFonts = options.collectFonts, collectFonts = _options_collectFonts === void 0 ? false : _options_collectFonts, _options_inlineImages = options.inlineImages, inlineImages = _options_inlineImages === void 0 ? false : _options_inlineImages, plugins = options.plugins, _options_keepIframeSrcFn = options.keepIframeSrcFn, keepIframeSrcFn = _options_keepIframeSrcFn === void 0 ? function() {
             return false;
         } : _options_keepIframeSrcFn, _options_ignoreCSSAttributes = options.ignoreCSSAttributes, ignoreCSSAttributes = _options_ignoreCSSAttributes === void 0 ? /* @__PURE__ */ new Set([]) : _options_ignoreCSSAttributes, errorHandler2 = options.errorHandler;
         registerErrorHandler(errorHandler2);
+        var validatedOrigins;
+        if (recordCrossOriginIframes && allowedIframeOrigins && allowedIframeOrigins.length > 0) {
+            validatedOrigins = buildAllowedOriginSet(allowedIframeOrigins);
+            if (validatedOrigins.size === 0) {
+                validatedOrigins = void 0;
+            }
+        }
         var inEmittingFrame = recordCrossOriginIframes ? window.parent === window : true;
         var passEmitsToParent = false;
         if (!inEmittingFrame) {
@@ -13405,7 +13448,14 @@
                     origin: window.location.origin,
                     isCheckout: isCheckout
                 };
-                window.parent.postMessage(message, "*");
+                if (validatedOrigins) {
+                    for(var _iterator = _create_for_of_iterator_helper_loose(validatedOrigins), _step; !(_step = _iterator()).done;){
+                        var targetOrigin = _step.value;
+                        window.parent.postMessage(message, targetOrigin);
+                    }
+                } else {
+                    window.parent.postMessage(message, "*");
+                }
             }
             if (e2.type === EventType.FullSnapshot) {
                 lastFullSnapshotEvent = e2;
@@ -18138,7 +18188,7 @@
     var __publicField = function(obj, key, value) {
         return __defNormalProp(obj, (typeof key === "undefined" ? "undefined" : _type_of(key)) !== "symbol" ? key + "" : key, value);
     };
-    function patch(source, name, replacement) {
+    function patch$3(source, name, replacement) {
         try {
             if (!(name in source)) {
                 return function() {};
@@ -18555,7 +18605,7 @@
             if (!_logger[level]) {
                 return function() {};
             }
-            return patch(_logger, level, function(original) {
+            return patch$3(_logger, level, function(original) {
                 var _this1 = _this;
                 return function() {
                     for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
@@ -18976,11 +19026,6 @@
         PromisePolyfill = NpoPromise;
     }
 
-    var Config = {
-        DEBUG: false,
-        LIB_VERSION: '2.75.0'
-    };
-
     /* eslint camelcase: "off", eqeqeq: "off" */
 
     // Maximum allowed session recording length
@@ -20712,6 +20757,17 @@
 
     var NOOP_FUNC = function () {};
 
+    var urlMatchesRegexList = function (url, regexList) {
+        var matches = false;
+        for (var i = 0; i < regexList.length; i++) {
+            if (url.match(regexList[i])) {
+                matches = true;
+                break;
+            }
+        }
+        return matches;
+    };
+
     var JSONStringify = null, JSONParse = null;
     if (typeof JSON !== 'undefined') {
         JSONStringify = JSON.stringify;
@@ -21183,7 +21239,7 @@
         };
     }
 
-    var logger$6 = console_with_prefix('lock');
+    var logger$8 = console_with_prefix('lock');
 
     /**
      * SharedLock: a mutex built on HTML5 localStorage, to ensure that only one browser
@@ -21235,7 +21291,7 @@
 
             var delay = function(cb) {
                 if (new Date().getTime() - startTime > timeoutMS) {
-                    logger$6.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
+                    logger$8.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
                     storage.removeItem(keyZ);
                     storage.removeItem(keyY);
                     loop();
@@ -21382,7 +21438,7 @@
         }, this));
     };
 
-    var logger$5 = console_with_prefix('batch');
+    var logger$7 = console_with_prefix('batch');
 
     /**
      * RequestQueue: queue for batching API requests with localStorage backup for retries.
@@ -21411,7 +21467,7 @@
                 timeoutMS: options.sharedLockTimeoutMS,
             });
         }
-        this.reportError = options.errorReporter || _.bind(logger$5.error, logger$5);
+        this.reportError = options.errorReporter || _.bind(logger$7.error, logger$7);
 
         this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios
 
@@ -21744,7 +21800,7 @@
     // maximum interval between request retries after exponential backoff
     var MAX_RETRY_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
 
-    var logger$4 = console_with_prefix('batch');
+    var logger$6 = console_with_prefix('batch');
 
     /**
      * RequestBatcher: manages the queueing, flushing, retry etc of requests of one
@@ -21872,7 +21928,7 @@
      */
     RequestBatcher.prototype.flush = function(options) {
         if (this.requestInProgress) {
-            logger$4.log('Flush: Request already in progress');
+            logger$6.log('Flush: Request already in progress');
             return PromisePolyfill.resolve();
         }
 
@@ -22049,7 +22105,7 @@
                 if (options.unloading) {
                     requestOptions.transport = 'sendBeacon';
                 }
-                logger$4.log('MIXPANEL REQUEST:', dataForRequest);
+                logger$6.log('MIXPANEL REQUEST:', dataForRequest);
                 return this.sendRequestPromise(dataForRequest, requestOptions).then(batchSendCallback);
             }, this))
             .catch(_.bind(function(err) {
@@ -22062,7 +22118,7 @@
      * Log error to global logger and optional user-defined logger.
      */
     RequestBatcher.prototype.reportError = function(msg, err) {
-        logger$4.error.apply(logger$4.error, arguments);
+        logger$6.error.apply(logger$6.error, arguments);
         if (this.errorReporter) {
             try {
                 if (!(err instanceof Error)) {
@@ -22070,7 +22126,7 @@
                 }
                 this.errorReporter(msg, err);
             } catch(err) {
-                logger$4.error(err);
+                logger$6.error(err);
             }
         }
     };
@@ -22087,6 +22143,29 @@
 
     var RECORD_ENQUEUE_THROTTLE_MS = 250;
 
+    var validateAllowedOrigins = function(origins, logger) {
+        if (!_.isArray(origins)) {
+            if (origins) {
+                logger.critical('record_allowed_iframe_origins must be an array of origin strings, cross-origin recording will be disabled.');
+            }
+            return [];
+        }
+        var valid = [];
+        for (var i = 0; i < origins.length; i++) {
+            try {
+                var origin = new URL(origins[i]).origin;
+                if (origin === 'null') {
+                    logger.critical(origins[i] + ' has an opaque origin. Skipping this entry.');
+                    continue;
+                }
+                valid.push(origin);
+            } catch (e) {
+                logger.critical(origins[i] + ' is not a valid origin URL. Skipping this entry.');
+            }
+        }
+        return valid;
+    };
+
     // stateless utils
     // mostly from https://github.com/mixpanel/mixpanel-js/blob/989ada50f518edab47b9c4fd9535f9fbd5ec5fc0/src/autotrack-utils.js
 
@@ -22192,7 +22271,7 @@
 
     var MAX_DEPTH = 5;
 
-    var logger$3 = console_with_prefix('autocapture');
+    var logger$5 = console_with_prefix('autocapture');
 
 
     function getClasses(el) {
@@ -22456,7 +22535,7 @@
                     return false;
                 }
             } catch (err) {
-                logger$3.critical('Error while checking element in allowElementCallback', err);
+                logger$5.critical('Error while checking element in allowElementCallback', err);
                 return false;
             }
         }
@@ -22473,7 +22552,7 @@
                     return true;
                 }
             } catch (err) {
-                logger$3.critical('Error while checking selector: ' + sel, err);
+                logger$5.critical('Error while checking selector: ' + sel, err);
             }
         }
         return false;
@@ -22488,7 +22567,7 @@
                     return true;
                 }
             } catch (err) {
-                logger$3.critical('Error while checking element in blockElementCallback', err);
+                logger$5.critical('Error while checking element in blockElementCallback', err);
                 return true;
             }
         }
@@ -22502,7 +22581,7 @@
                         return true;
                     }
                 } catch (err) {
-                    logger$3.critical('Error while checking selector: ' + sel, err);
+                    logger$5.critical('Error while checking selector: ' + sel, err);
                 }
             }
         }
@@ -23050,177 +23129,826 @@
     }
 
     /**
-     * @typedef {import('../index').RecordPrivacyConfig} RecordPrivacyConfig
+     * This is a port of the open rrweb network plugin in this PR https://github.com/rrweb-io/rrweb/pull/1105
+     * the hope is that eventually this can be replaced with the official plugin once it's published (and we sync the mixpanel rrweb fork)
+     *
+     * This plugin incorporates some important fixes for fetch/XHR body recording that are not yet in the main rrweb repo, as well as makes
+     * header and body recording more restrictive by requiring an allowlist instead of content type / blocklist.
+     *
      */
 
+    var logger$4 = console_with_prefix('network-plugin');
 
-    var logger$2 = console_with_prefix('recorder');
-    var CompressionStream = win['CompressionStream'];
-
-    var RECORDER_BATCHER_LIB_CONFIG = {
-        'batch_size': 1000,
-        'batch_flush_interval_ms': 10 * 1000,
-        'batch_request_timeout_ms': 90 * 1000,
-        'batch_autostart': true
-    };
+    /**
+     * Get the time origin for converting performance timestamps to absolute timestamps.
+     * Uses Date.now() - performance.now() instead of performance.timeOrigin because
+     * browsers can report timeOrigin values that are skewed from actual time, and some
+     * browsers (notably older Safari versions) don't implement timeOrigin at all.
+     * See: https://github.com/getsentry/sentry-javascript/blob/e856e40b6e71a73252e788cd42b5260f81c9c88e/packages/utils/src/time.ts#L49-L70
+     * @param {Window} win
+     * @returns {number}
+     */
+    function getTimeOrigin(win) {
+        return Math.round(Date.now() - win.performance.now());
+    }
 
-    var ACTIVE_SOURCES = new Set([
-        IncrementalSource.MouseMove,
-        IncrementalSource.MouseInteraction,
-        IncrementalSource.Scroll,
-        IncrementalSource.ViewportResize,
-        IncrementalSource.Input,
-        IncrementalSource.TouchMove,
-        IncrementalSource.MediaInteraction,
-        IncrementalSource.Drag,
-        IncrementalSource.Selection,
-    ]);
+    /**
+     * @typedef {import('../index.d.ts').InitiatorType} InitiatorType
+     * @typedef {import('../index.d.ts').NetworkRequest} NetworkRequest
+     * @typedef {import('../index.d.ts').NetworkRecordOptions} NetworkRecordOptions
+     * @typedef {import('../index.d.ts').NetworkData} NetworkData
+     */
 
-    function isUserEvent(ev) {
-        return ev.type === EventType.IncrementalSnapshot && ACTIVE_SOURCES.has(ev.data.source);
-    }
+    /**
+     * @typedef {Record<string, string>} Headers
+     */
 
     /**
-     * @typedef {Object} SerializedRecording
-     * @property {number} idleExpires
-     * @property {number} maxExpires
-     * @property {number} replayStartTime
-     * @property {number} lastEventTimestamp
-     * @property {number} seqNo
-     * @property {string} batchStartUrl
-     * @property {string} replayId
-     * @property {string} tabId
-     * @property {string} replayStartUrl
+     * @typedef {string | Document | Blob | ArrayBufferView | ArrayBuffer | FormData | URLSearchParams | ReadableStream<Uint8Array> | null} Body
      */
 
     /**
-     * @typedef {Object} SessionRecordingOptions
-     * @property {Object} [options.mixpanelInstance] - reference to the core MixpanelLib
-     * @property {String} [options.replayId] - unique uuid for a single replay
-     * @property {Function} [options.onIdleTimeout] - callback when a recording reaches idle timeout
-     * @property {Function} [options.onMaxLengthReached] - callback when a recording reaches its maximum length
-     * @property {import('./rrweb-entrypoint').record} [options.rrwebRecord] - rrweb's `record` function
-     * @property {Function} [options.onBatchSent] - callback when a batch of events is sent to the server
-     * @property {Storage} [options.sharedLockStorage] - optional storage for shared lock, used for test dependency injection
-     * optional properties for deserialization:
-     * @property {number} idleExpires
-     * @property {number} maxExpires
-     * @property {number} replayStartTime
-     * @property {number} lastEventTimestamp - the unix timestamp of the last recorded event from rrweb
-     * @property {number} seqNo
-     * @property {string} batchStartUrl
-     * @property {string} replayStartUrl
+     * @callback networkCallback
+     * @param {NetworkData} data
+     * @returns {void}
      */
 
     /**
-     * @typedef {Object} UserIdInfo
-     * @property {string} distinct_id
-     * @property {string} user_id
-     * @property {string} device_id
+     * @callback listenerHandler
+     * @returns {void}
      */
 
+    /**
+     * @typedef {(PerformanceNavigationTiming | PerformanceResourceTiming) & { responseStatus?: number }} ObservedPerformanceEntry
+     */
 
     /**
-     * This class encapsulates a single session recording and its lifecycle.
-     * @param {SessionRecordingOptions} options
+     * @typedef {Object} RecordPlugin
+     * @property {string} name
+     * @property {(callback: networkCallback, win: Window, options: NetworkRecordOptions) => listenerHandler} observer
+     * @property {NetworkRecordOptions} [options]
      */
-    var SessionRecording = function(options) {
-        this._mixpanel = options.mixpanelInstance;
-        this._onIdleTimeout = options.onIdleTimeout || NOOP_FUNC;
-        this._onMaxLengthReached = options.onMaxLengthReached || NOOP_FUNC;
-        this._onBatchSent = options.onBatchSent || NOOP_FUNC;
-        this._rrwebRecord = options.rrwebRecord || null;
 
-        // internal rrweb stopRecording function
-        this._stopRecording = null;
-        this.replayId = options.replayId;
+    /** @type {Required<NetworkRecordOptions>} */
+    var defaultNetworkOptions = {
+        initiatorTypes: [
+            'audio',
+            'beacon',
+            'body',
+            'css',
+            'early-hint',
+            'embed',
+            'fetch',
+            'frame',
+            'iframe',
+            'icon',
+            'image',
+            'img',
+            'input',
+            'link',
+            'navigation',
+            'object',
+            'ping',
+            'script',
+            'track',
+            'video',
+            'xmlhttprequest',
+        ],
+        ignoreRequestFn: function() { return false; },
+        recordHeaders: {
+            request: [],
+            response: [],
+        },
+        recordBodyUrls: {
+            request: [],
+            response: [],
+        },
+        recordInitialRequests: false,
+    };
 
-        this.batchStartUrl = options.batchStartUrl || null;
-        this.replayStartUrl = options.replayStartUrl || null;
-        this.idleExpires = options.idleExpires || null;
-        this.maxExpires = options.maxExpires || null;
-        this.replayStartTime = options.replayStartTime || null;
-        this.lastEventTimestamp = options.lastEventTimestamp || null;
-        this.seqNo = options.seqNo || 0;
+    /**
+     * @param {PerformanceEntry} entry
+     * @returns {entry is PerformanceNavigationTiming}
+     */
+    function isNavigationTiming(entry) {
+        return entry.entryType === 'navigation';
+    }
 
-        this.idleTimeoutId = null;
-        this.maxTimeoutId = null;
+    /**
+     * @param {PerformanceEntry} entry
+     * @returns {entry is PerformanceResourceTiming}
+     */
+    function isResourceTiming (entry) {
+        return entry.entryType === 'resource';
+    }
 
-        this.recordMaxMs = MAX_RECORDING_MS;
-        this.recordMinMs = 0;
+    function findLast(array, predicate) {
+        var length = array.length;
+        for (var i = length - 1; i >= 0; i -= 1) {
+            if (predicate(array[i])) {
+                return array[i];
+            }
+        }
+    }
 
-        // 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');
+    /**
+     * Monkey-patches a method on an object with a wrapped version, returning a function that restores the original.
+     * Adapted from Sentry's `fill` utility:
+     * https://github.com/getsentry/sentry-javascript/blob/de5c5cbe177b4334386e747857225eec36a91ea1/packages/core/src/utils/object.ts#L67-L95
+     *
+     * @param {object} source - The object containing the method to patch
+     * @param {string} name - The method name to patch
+     * @param {function} replacementFactory - A function that receives the original method and returns the replacement
+     * @returns {function} A function that restores the original method
+     */
+    function patch(source, name, replacementFactory) {
+        if (!(name in source) || typeof source[name] !== 'function') {
+            return function() {};
+        }
+        var original = source[name];
+        var wrapped = replacementFactory(original);
+        source[name] = wrapped;
+        return function() {
+            source[name] = original;
+        };
+    }
 
-        // 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.batcher = new RequestBatcher(this.batcherKey, {
-            errorReporter: this.reportError.bind(this),
-            flushOnlyOnInterval: true,
-            libConfig: RECORDER_BATCHER_LIB_CONFIG,
-            sendRequestFunc: this.flushEventsWithOptOut.bind(this),
-            queueStorage: this.queueStorage,
-            sharedLockStorage: options.sharedLockStorage,
-            usePersistence: usePersistence,
-            stopAllBatchingFunc: this.stopRecording.bind(this),
 
-            // increased throttle and shared lock timeout because recording events are very high frequency.
-            // this will minimize the amount of lock contention between enqueued events.
-            // for session recordings there is a lock for each tab anyway, so there's no risk of deadlock between tabs.
-            enqueueThrottleMs: RECORD_ENQUEUE_THROTTLE_MS,
-            sharedLockTimeoutMS: 10 * 1000,
-        });
-    };
+    /**
+     * Maximum body size to record (1MB)
+     */
+    var MAX_BODY_SIZE = 1024 * 1024;
 
     /**
-     * @returns {UserIdInfo}
+     * Truncate string if it exceeds max size
+     * @param {string} str
+     * @returns {string}
      */
-    SessionRecording.prototype.getUserIdInfo = function () {
-        if (this.finalFlushUserIdInfo) {
-            return this.finalFlushUserIdInfo;
+    function truncateBody(str) {
+        if (!str || typeof str !== 'string') {
+            return str;
+        }
+        if (str.length > MAX_BODY_SIZE) {
+            logger$4.error('Body truncated from ' + str.length + ' to ' + MAX_BODY_SIZE + ' characters');
+            return str.substring(0, MAX_BODY_SIZE) + '... [truncated]';
         }
+        return str;
+    }
 
-        var userIdInfo = {
-            'distinct_id': String(this._mixpanel.get_distinct_id()),
+    /**
+     * @param {networkCallback} cb
+     * @param {Window} win
+     * @param {Required<NetworkRecordOptions>} options
+     * @returns {listenerHandler}
+     */
+    function initPerformanceObserver(cb, win, options) {
+        if (!win.PerformanceObserver) {
+            logger$4.error('PerformanceObserver not supported');
+            return function() {
+                //
+            };
+        }
+        if (options.recordInitialRequests) {
+            var initialPerformanceEntries = win.performance
+                .getEntries()
+                .filter(function(entry) {
+                    return isNavigationTiming(entry) ||
+              (isResourceTiming(entry) &&
+                options.initiatorTypes.includes(entry.initiatorType));
+                });
+            cb({
+                requests: initialPerformanceEntries.map(function(entry) {
+                    return {
+                        url: entry.name,
+                        initiatorType: /** @type {InitiatorType} */ (entry.initiatorType),
+                        status: 'responseStatus' in entry ? entry.responseStatus : undefined,
+                        startTime: Math.round(entry.startTime),
+                        endTime: Math.round(entry.responseEnd),
+                        timeOrigin: getTimeOrigin(win),
+                    };
+                }),
+                isInitial: true,
+            });
+        }
+        var observer = new win.PerformanceObserver(function(entries) {
+            var performanceEntries = entries
+                .getEntries()
+                .filter(function(entry) {
+                    return isResourceTiming(entry) &&
+                        options.initiatorTypes.includes(entry.initiatorType) &&
+                        entry.initiatorType !== 'xmlhttprequest' &&
+                        entry.initiatorType !== 'fetch';
+                });
+            cb({
+                requests: performanceEntries.map(function(entry) {
+                    return {
+                        url: entry.name,
+                        initiatorType: /** @type {InitiatorType} */ (entry.initiatorType),
+                        status: 'responseStatus' in entry ? entry.responseStatus : undefined,
+                        startTime: Math.round(entry.startTime),
+                        endTime: Math.round(entry.responseEnd),
+                        timeOrigin: getTimeOrigin(win),
+                    };
+                }),
+            });
+        });
+        observer.observe({ entryTypes: ['navigation', 'resource'] });
+        return function() {
+            observer.disconnect();
         };
+    }
 
-        // send ID management props if they exist
-        var deviceId = this._mixpanel.get_property('$device_id');
-        if (deviceId) {
-            userIdInfo['$device_id'] = deviceId;
-        }
-        var userId = this._mixpanel.get_property('$user_id');
-        if (userId) {
-            userIdInfo['$user_id'] = userId;
+    /**
+     * Variation of the original rrweb function that requires an allowlist for headers instead of supporting boolean options
+     * @param {'request' | 'response'} type
+     * @param {NetworkRecordOptions['recordHeaders']} recordHeaders
+     * @param {string} headerName
+     * @returns {boolean}
+     */
+    function shouldRecordHeader(type, recordHeaders, headerName) {
+        if (!recordHeaders[type] || recordHeaders[type].length === 0) {
+            return false;
         }
-        return userIdInfo;
-    };
 
-    SessionRecording.prototype.unloadPersistedData = function () {
-        this.batcher.stop();
+        return recordHeaders[type].includes(headerName.toLowerCase());
+    }
 
-        return this.queueStorage.init().catch(function () {
-            this.reportError('Error initializing IndexedDB storage for unloading persisted data.');
-        }.bind(this)).then(function () {
-            // if the recording is too short, just delete any stored events without flushing
-            if (this.getDurationMs() < this._getRecordMinMs()) {
-                return this.queueStorage.removeItem(this.batcherKey);
-            }
+    /**
+     * Variation of the original rrweb function that requires an allowlist for URLs instead of supporting boolean options or by content type
+     * @param {'request' | 'response'} type
+     * @param {NetworkRecordOptions['recordBodyUrls']} recordBodyUrls
+     * @param {string} url
+     * @returns {boolean}
+     */
+    function shouldRecordBody(type, recordBodyUrls, url) {
+        if (!recordBodyUrls[type] || recordBodyUrls[type].length === 0) {
+            return false;
+        }
 
-            return this.batcher.flush()
-                .then(function () {
-                    return this.queueStorage.removeItem(this.batcherKey);
-                }.bind(this));
-        }.bind(this));
-    };
+        return urlMatchesRegexList(url, recordBodyUrls[type]);
+    }
 
-    SessionRecording.prototype.getConfig = function(configVar) {
-        return this._mixpanel.get_config(configVar);
-    };
+    function tryReadXHRBody(body) {
+        if (body === null || body === undefined) {
+            return null;
+        }
 
-    // Alias for getConfig, used by the common addOptOutCheckMixpanelLib function which
+        var result;
+        if (typeof body === 'string') {
+            result = body;
+        } else if (body instanceof Document) {
+            result = body.textContent;
+        } else if (body instanceof FormData) {
+            result = _.HTTPBuildQuery(body);
+        } else if (_.isObject(body)) {
+            try {
+                result = JSON.stringify(body);
+            } catch (e) {
+                return 'Failed to stringify response object';
+            }
+        } else {
+            return 'Cannot read body of type ' + typeof body;
+        }
+
+        return truncateBody(result);
+    }
+
+    /**
+     * @param {Request | Response} r
+     * @returns {Promise<string>}
+     */
+    function tryReadFetchBody(r) {
+        return new Promise(function(resolve) {
+            var timeout = setTimeout(function() {
+                resolve('Timeout while trying to read body');
+            }, 500);
+            try {
+                r.clone()
+                    .text()
+                    .then(
+                        function(txt) {
+                            clearTimeout(timeout);
+                            resolve(truncateBody(txt));
+                        },
+                        function(reason) {
+                            clearTimeout(timeout);
+                            resolve('Failed to read body: ' + String(reason));
+                        }
+                    );
+            } catch (e) {
+                clearTimeout(timeout);
+                resolve('Failed to read body: ' + String(e));
+            }
+        });
+    }
+
+    /**
+     * @param {Window} win
+     * @param {string} initiatorType
+     * @param {string} url
+     * @param {number} [after]
+     * @param {number} [before]
+     * @param {number} [attempt]
+     * @returns {Promise<PerformanceResourceTiming>}
+     */
+    function getRequestPerformanceEntry(win, initiatorType, url, after, before, attempt) {
+        if (attempt === undefined) {
+            attempt = 0;
+        }
+        if (attempt > 10) {
+            logger$4.error('Cannot find performance entry');
+            return Promise.resolve(null);
+        }
+        var urlPerformanceEntries = /** @type {PerformanceResourceTiming[]} */ (
+            win.performance.getEntriesByName(url)
+        );
+        var performanceEntry = findLast(
+            urlPerformanceEntries,
+            function(entry) {
+                return isResourceTiming(entry) &&
+            entry.initiatorType === initiatorType &&
+            (!after || entry.startTime >= after) &&
+            (!before || entry.startTime <= before);
+            }
+        );
+        if (!performanceEntry) {
+            return new Promise(function(resolve) {
+                setTimeout(resolve, 50 * attempt);
+            }).then(function() {
+                return getRequestPerformanceEntry(
+                    win,
+                    initiatorType,
+                    url,
+                    after,
+                    before,
+                    attempt + 1
+                );
+            });
+        }
+        return Promise.resolve(performanceEntry);
+    }
+
+    /**
+     * @param {networkCallback} cb
+     * @param {Window} win
+     * @param {Required<NetworkRecordOptions>} options
+     * @returns {listenerHandler}
+     */
+    function initXhrObserver(cb, win, options) {
+        if (!options.initiatorTypes.includes('xmlhttprequest')) {
+            return function() {
+                //
+            };
+        }
+        var restorePatch = patch(
+            win.XMLHttpRequest.prototype,
+            'open',
+            function(/** @type {typeof XMLHttpRequest.prototype.open} */ originalOpen) {
+                return function(
+                    /** @type {string} */ method,
+                    /** @type {string | URL} */ url,
+                    /** @type {boolean} */ async,
+                    username, password
+                ) {
+                    if (async === undefined) {
+                        async = true;
+                    }
+                    var xhr = /** @type {XMLHttpRequest} */ (this);
+                    var req = new Request(url, { method: method });
+                    /** @type {Partial<NetworkRequest>} */
+                    var networkRequest = {};
+                    /** @type {number | undefined} */
+                    var after;
+                    /** @type {number | undefined} */
+                    var before;
+
+                    /** @type {Headers} */
+                    var requestHeaders = {};
+                    var originalSetRequestHeader = xhr.setRequestHeader.bind(xhr);
+                    xhr.setRequestHeader = function(/** @type {string} */ header, /** @type {string} */ value) {
+                        if (shouldRecordHeader('request', options.recordHeaders, header)) {
+                            requestHeaders[header] = value;
+                        }
+                        return originalSetRequestHeader(header, value);
+                    };
+                    networkRequest.requestHeaders = requestHeaders;
+
+                    var originalSend = xhr.send.bind(xhr);
+                    xhr.send = function(/** @type {Body} */ body) {
+                        if (shouldRecordBody('request', options.recordBodyUrls, req.url)) {
+                            networkRequest.requestBody = tryReadXHRBody(body);
+                        }
+                        after = win.performance.now();
+                        return originalSend(body);
+                    };
+                    xhr.addEventListener('readystatechange', function() {
+                        if (xhr.readyState !== xhr.DONE) {
+                            return;
+                        }
+                        before = win.performance.now();
+                        /** @type {Headers} */
+                        var responseHeaders = {};
+                        var rawHeaders = xhr.getAllResponseHeaders();
+                        if (rawHeaders) {
+                            var headers = rawHeaders.trim().split(/[\r\n]+/);
+                            headers.forEach(function(line) {
+                                if (!line) return;
+                                var colonIndex = line.indexOf(': ');
+                                if (colonIndex === -1) return;
+                                var header = line.substring(0, colonIndex);
+                                var value = line.substring(colonIndex + 2);
+                                if (header && shouldRecordHeader('response', options.recordHeaders, header)) {
+                                    responseHeaders[header] = value;
+                                }
+                            });
+                        }
+                        networkRequest.responseHeaders = responseHeaders;
+                        if (
+                            shouldRecordBody('response', options.recordBodyUrls, req.url)
+                        ) {
+                            networkRequest.responseBody = tryReadXHRBody(xhr.response);
+                        }
+                        getRequestPerformanceEntry(
+                            win,
+                            'xmlhttprequest',
+                            req.url,
+                            after,
+                            before
+                        )
+                            .then(function(entry) {
+                                if (!entry) {
+                                    logger$4.error('Failed to get performance entry for XHR request to ' + req.url);
+                                    return;
+                                }
+                                /** @type {NetworkRequest} */
+                                var request = {
+                                    url: entry.name,
+                                    method: req.method,
+                                    initiatorType: /** @type {InitiatorType} */ (entry.initiatorType),
+                                    status: xhr.status,
+                                    startTime: Math.round(entry.startTime),
+                                    endTime: Math.round(entry.responseEnd),
+                                    timeOrigin: getTimeOrigin(win),
+                                    requestHeaders: networkRequest.requestHeaders,
+                                    requestBody: networkRequest.requestBody,
+                                    responseHeaders: networkRequest.responseHeaders,
+                                    responseBody: networkRequest.responseBody,
+                                };
+                                cb({ requests: [request] });
+                            })
+                            .catch(function(e) {
+                                logger$4.error('Error recording XHR request to ' + req.url + ': ' + String(e));
+                            });
+                    });
+
+                    originalOpen.call(xhr, method, url, async, username, password);
+                };
+            }
+        );
+        return function() {
+            restorePatch();
+        };
+    }
+
+    /**
+     * @param {networkCallback} cb
+     * @param {Window} win
+     * @param {Required<NetworkRecordOptions>} options
+     * @returns {listenerHandler}
+     */
+    function initFetchObserver(cb, win, options) {
+        if (!options.initiatorTypes.includes('fetch')) {
+            return function() {
+                //
+            };
+        }
+
+        var restorePatch = patch(win, 'fetch', function(/** @type {typeof fetch} */ originalFetch) {
+            return function() {
+                var req = new Request(arguments[0], arguments[1]);
+                /** @type {Response | undefined} */
+                var res;
+                /** @type {Partial<NetworkRequest>} */
+                var networkRequest = {};
+                /** @type {number | undefined} */
+                var after;
+                /** @type {number | undefined} */
+                var before;
+
+                var originalFetchPromise;
+                var requestBodyPromise = Promise.resolve(undefined);
+                var responseBodyPromise = Promise.resolve(undefined);
+                try {
+                    /** @type {Headers} */
+                    var requestHeaders = {};
+                    req.headers.forEach(function(value, header) {
+                        if (shouldRecordHeader('request', options.recordHeaders, header)) {
+                            requestHeaders[header] = value;
+                        }
+                    });
+                    networkRequest.requestHeaders = requestHeaders;
+
+                    if (shouldRecordBody('request', options.recordBodyUrls, req.url)) {
+                        requestBodyPromise = tryReadFetchBody(req)
+                            .then(function(body) {
+                                networkRequest.requestBody = body;
+                            });
+                    }
+
+                    after = win.performance.now();
+                    originalFetchPromise = originalFetch.apply(win, arguments).then(function(response) {
+                        res = response;
+                        before = win.performance.now();
+
+                        /** @type {Headers} */
+                        var responseHeaders = {};
+                        res.headers.forEach(function(value, header) {
+                            if (shouldRecordHeader('response', options.recordHeaders, header)) {
+                                responseHeaders[header] = value;
+                            }
+                        });
+                        networkRequest.responseHeaders = responseHeaders;
+
+                        if (shouldRecordBody('response', options.recordBodyUrls, req.url)) {
+                            responseBodyPromise = tryReadFetchBody(res)
+                                .then(function(body) {
+                                    networkRequest.responseBody = body;
+                                });
+                        }
+
+                        return res;
+                    });
+                } catch (e) {
+                    originalFetchPromise = Promise.reject(e);
+                }
+
+                // await concurrently so we don't delay the fetch response
+                Promise.all([requestBodyPromise, responseBodyPromise, originalFetchPromise])
+                    .then(function () {
+                        return getRequestPerformanceEntry(win, 'fetch', req.url, after, before);
+                    })
+                    .then(function(entry) {
+                        if (!entry) {
+                            logger$4.error('Failed to get performance entry for fetch request to ' + req.url);
+                            return;
+                        }
+                        /** @type {NetworkRequest} */
+                        var request = {
+                            url: entry.name,
+                            method: req.method,
+                            initiatorType: /** @type {InitiatorType} */ (entry.initiatorType),
+                            status: res ? res.status : undefined,
+                            startTime: Math.round(entry.startTime),
+                            endTime: Math.round(entry.responseEnd),
+                            timeOrigin: getTimeOrigin(win),
+                            requestHeaders: networkRequest.requestHeaders,
+                            requestBody: networkRequest.requestBody,
+                            responseHeaders: networkRequest.responseHeaders,
+                            responseBody: networkRequest.responseBody,
+                        };
+                        cb({ requests: [request] });
+                    })
+                    .catch(function (e) {
+                        logger$4.error('Error recording fetch request to ' + req.url + ': ' + String(e));
+                    });
+
+                return originalFetchPromise;
+            };
+        });
+        return function() {
+            restorePatch();
+        };
+    }
+
+    /**
+     * @param {networkCallback} callback
+     * @param {Window} win
+     * @param {NetworkRecordOptions} options
+     * @returns {listenerHandler}
+     */
+    function initNetworkObserver(callback, win, options) {
+        if (!('performance' in win)) {
+            return function() {
+                //
+            };
+        }
+
+        var recordHeaders = Object.assign({}, defaultNetworkOptions.recordHeaders, options.recordHeaders || {});
+        var recordBodyUrls = Object.assign({}, defaultNetworkOptions.recordBodyUrls, options.recordBodyUrls || {});
+        options = Object.assign({}, options, {
+            recordHeaders: recordHeaders,
+            recordBodyUrls: recordBodyUrls,
+        });
+        var networkOptions = /** @type {Required<NetworkRecordOptions>} */ Object.assign({}, defaultNetworkOptions, options);
+
+        /** @type {networkCallback} */
+        var cb = function(data) {
+            var requests = data.requests.filter(function(request) {
+                var shouldIgnoreUrl = urlMatchesRegexList(request.url, networkOptions.ignoreRequestUrls || []);
+                return !shouldIgnoreUrl && !networkOptions.ignoreRequestFn(request);
+            });
+            if (requests.length > 0 || data.isInitial) {
+                callback(Object.assign({}, data, { requests: requests }));
+            }
+        };
+        var performanceObserver = initPerformanceObserver(cb, win, networkOptions);
+        var xhrObserver = initXhrObserver(cb, win, networkOptions);
+        var fetchObserver = initFetchObserver(cb, win, networkOptions);
+        return function() {
+            performanceObserver();
+            xhrObserver();
+            fetchObserver();
+        };
+    }
+
+    // arbitrary .mp suffix in case rrweb does publish this plugin later and we use it but need to handle
+    // a changed format in the mixpanel product.
+    var NETWORK_PLUGIN_NAME = 'rrweb/network@1.mp';
+
+    /**
+     * @param {NetworkRecordOptions} [options]
+     * @returns {RecordPlugin}
+     */
+    var getRecordNetworkPlugin = function(options) {
+        return {
+            name: NETWORK_PLUGIN_NAME,
+            observer: initNetworkObserver,
+            options: options,
+        };
+    };
+
+    /**
+     * @typedef {import('../index').RecordPrivacyConfig} RecordPrivacyConfig
+     */
+
+
+    var logger$3 = console_with_prefix('recorder');
+    var CompressionStream = win['CompressionStream'];
+
+    var RECORDER_BATCHER_LIB_CONFIG = {
+        'batch_size': 1000,
+        'batch_flush_interval_ms': 10 * 1000,
+        'batch_request_timeout_ms': 90 * 1000,
+        'batch_autostart': true
+    };
+
+    var ACTIVE_SOURCES = new Set([
+        IncrementalSource.MouseMove,
+        IncrementalSource.MouseInteraction,
+        IncrementalSource.Scroll,
+        IncrementalSource.ViewportResize,
+        IncrementalSource.Input,
+        IncrementalSource.TouchMove,
+        IncrementalSource.MediaInteraction,
+        IncrementalSource.Drag,
+        IncrementalSource.Selection,
+    ]);
+
+    function isUserEvent(ev) {
+        return ev.type === EventType.IncrementalSnapshot && ACTIVE_SOURCES.has(ev.data.source);
+    }
+
+    /**
+     * @typedef {Object} SerializedRecording
+     * @property {number} idleExpires
+     * @property {number} maxExpires
+     * @property {number} replayStartTime
+     * @property {number} lastEventTimestamp
+     * @property {number} seqNo
+     * @property {string} batchStartUrl
+     * @property {string} replayId
+     * @property {string} tabId
+     * @property {string} replayStartUrl
+     */
+
+    /**
+     * @typedef {Object} SessionRecordingOptions
+     * @property {Object} [options.mixpanelInstance] - reference to the core MixpanelLib
+     * @property {String} [options.replayId] - unique uuid for a single replay
+     * @property {Function} [options.onIdleTimeout] - callback when a recording reaches idle timeout
+     * @property {Function} [options.onMaxLengthReached] - callback when a recording reaches its maximum length
+     * @property {import('./rrweb-entrypoint').record} [options.rrwebRecord] - rrweb's `record` function
+     * @property {Function} [options.onBatchSent] - callback when a batch of events is sent to the server
+     * @property {Storage} [options.sharedLockStorage] - optional storage for shared lock, used for test dependency injection
+     * optional properties for deserialization:
+     * @property {number} idleExpires
+     * @property {number} maxExpires
+     * @property {number} replayStartTime
+     * @property {number} lastEventTimestamp - the unix timestamp of the last recorded event from rrweb
+     * @property {number} seqNo
+     * @property {string} batchStartUrl
+     * @property {string} replayStartUrl
+     */
+
+    /**
+     * @typedef {Object} UserIdInfo
+     * @property {string} distinct_id
+     * @property {string} user_id
+     * @property {string} device_id
+     */
+
+
+    /**
+     * This class encapsulates a single session recording and its lifecycle.
+     * @param {SessionRecordingOptions} options
+     */
+    var SessionRecording = function(options) {
+        this._mixpanel = options.mixpanelInstance;
+        this._onIdleTimeout = options.onIdleTimeout || NOOP_FUNC;
+        this._onMaxLengthReached = options.onMaxLengthReached || NOOP_FUNC;
+        this._onBatchSent = options.onBatchSent || NOOP_FUNC;
+        this._rrwebRecord = options.rrwebRecord || null;
+
+        // internal rrweb stopRecording function
+        this._stopRecording = null;
+        this.replayId = options.replayId;
+
+        this.batchStartUrl = options.batchStartUrl || null;
+        this.replayStartUrl = options.replayStartUrl || null;
+        this.idleExpires = options.idleExpires || null;
+        this.maxExpires = options.maxExpires || null;
+        this.replayStartTime = options.replayStartTime || null;
+        this.lastEventTimestamp = options.lastEventTimestamp || null;
+        this.seqNo = options.seqNo || 0;
+
+        this.idleTimeoutId = null;
+        this.maxTimeoutId = null;
+
+        this.recordMaxMs = MAX_RECORDING_MS;
+        this.recordMinMs = 0;
+
+        // 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');
+
+        // 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.batcher = new RequestBatcher(this.batcherKey, {
+            errorReporter: this.reportError.bind(this),
+            flushOnlyOnInterval: true,
+            libConfig: RECORDER_BATCHER_LIB_CONFIG,
+            sendRequestFunc: this.flushEventsWithOptOut.bind(this),
+            queueStorage: this.queueStorage,
+            sharedLockStorage: options.sharedLockStorage,
+            usePersistence: usePersistence,
+            stopAllBatchingFunc: this.stopRecording.bind(this),
+
+            // increased throttle and shared lock timeout because recording events are very high frequency.
+            // this will minimize the amount of lock contention between enqueued events.
+            // for session recordings there is a lock for each tab anyway, so there's no risk of deadlock between tabs.
+            enqueueThrottleMs: RECORD_ENQUEUE_THROTTLE_MS,
+            sharedLockTimeoutMS: 10 * 1000,
+        });
+    };
+
+    /**
+     * @returns {UserIdInfo}
+     */
+    SessionRecording.prototype.getUserIdInfo = function () {
+        if (this.finalFlushUserIdInfo) {
+            return this.finalFlushUserIdInfo;
+        }
+
+        var userIdInfo = {
+            'distinct_id': String(this._mixpanel.get_distinct_id()),
+        };
+
+        // send ID management props if they exist
+        var deviceId = this._mixpanel.get_property('$device_id');
+        if (deviceId) {
+            userIdInfo['$device_id'] = deviceId;
+        }
+        var userId = this._mixpanel.get_property('$user_id');
+        if (userId) {
+            userIdInfo['$user_id'] = userId;
+        }
+        return userIdInfo;
+    };
+
+    SessionRecording.prototype.unloadPersistedData = function () {
+        this.batcher.stop();
+
+        return this.queueStorage.init().catch(function () {
+            this.reportError('Error initializing IndexedDB storage for unloading persisted data.');
+        }.bind(this)).then(function () {
+            // if the recording is too short, just delete any stored events without flushing
+            if (this.getDurationMs() < this._getRecordMinMs()) {
+                return this.queueStorage.removeItem(this.batcherKey);
+            }
+
+            return this.batcher.flush()
+                .then(function () {
+                    return this.queueStorage.removeItem(this.batcherKey);
+                }.bind(this));
+        }.bind(this));
+    };
+
+    SessionRecording.prototype.getConfig = function(configVar) {
+        return this._mixpanel.get_config(configVar);
+    };
+
+    // Alias for getConfig, used by the common addOptOutCheckMixpanelLib function which
     // reaches into this class instance and expects the snake case version of the function.
     // eslint-disable-next-line camelcase
     SessionRecording.prototype.get_config = function(configVar) {
@@ -23234,14 +23962,14 @@
         }
 
         if (this._stopRecording !== null) {
-            logger$2.log('Recording already in progress, skipping startRecording.');
+            logger$3.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$2.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
+            logger$3.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
         }
 
         if (!this.maxExpires) {
@@ -23282,6 +24010,31 @@
 
         var privacyConfig = getPrivacyConfig(this._mixpanel);
 
+        var plugins = [];
+        if (this.getConfig('record_network')) {
+            var options = this.getConfig('record_network_options') || {};
+            // don't track requests to Mixpanel /record API
+            var ignoreRequestUrls = (options.ignoreRequestUrls || []).slice();
+            ignoreRequestUrls.push(this._getApiRoute());
+            options.ignoreRequestUrls = ignoreRequestUrls;
+
+            plugins.push(getRecordNetworkPlugin(options));
+        }
+
+        if (this.getConfig('record_console')) {
+            plugins.push(
+                getRecordConsolePlugin({
+                    stringifyOptions: {
+                        stringLengthLimit: 1000,
+                        numOfKeysLimit: 50,
+                        depthOfLimit: 2
+                    }
+                })
+            );
+        }
+
+        var validatedOrigins = validateAllowedOrigins(this.getConfig('record_allowed_iframe_origins'), logger$3);
+
         try {
             this._stopRecording = this._rrwebRecord({
                 'emit': function (ev) {
@@ -23316,19 +24069,13 @@
                 'maskTextSelector': '*',
                 'maskInputFn': this._getMaskFn(shouldMaskInput, privacyConfig),
                 'maskTextFn': this._getMaskFn(shouldMaskText, privacyConfig),
+                'recordCrossOriginIframes': validatedOrigins.length > 0,
+                'allowedIframeOrigins': validatedOrigins,
                 'recordCanvas': this.getConfig('record_canvas'),
                 'sampling': {
                     'canvas': 15
                 },
-                'plugins': this.getConfig('record_console') ? [
-                    getRecordConsolePlugin({
-                        stringifyOptions: {
-                            stringLengthLimit: 1000,
-                            numOfKeysLimit: 50,
-                            depthOfLimit: 2
-                        }
-                    })
-                ] : []
+                'plugins': plugins,
             });
         } catch (err) {
             this.reportError('Unexpected error when starting rrweb recording.', err);
@@ -23443,6 +24190,10 @@
         return recording;
     };
 
+    SessionRecording.prototype._getApiRoute = function () {
+        return this.getConfig('api_routes')['record'];
+    };
+
     SessionRecording.prototype._sendRequest = function(currentReplayId, reqParams, reqBody, callback) {
         var onSuccess = function (response, responseBody) {
             // Update batch specific props only if the request was successful to guarantee ordering.
@@ -23462,7 +24213,7 @@
             });
         }.bind(this);
         var apiHost = (this._mixpanel.get_api_host && this._mixpanel.get_api_host('record')) || this.getConfig('api_host');
-        win['fetch'](apiHost + '/' + this.getConfig('api_routes')['record'] + '?' + new URLSearchParams(reqParams), {
+        win['fetch'](apiHost + '/' + this._getApiRoute() + '?' + new URLSearchParams(reqParams), {
             'method': 'POST',
             'headers': {
                 'Authorization': 'Basic ' + btoa(this.getConfig('token') + ':'),
@@ -23544,14 +24295,14 @@
 
 
     SessionRecording.prototype.reportError = function(msg, err) {
-        logger$2.error.apply(logger$2.error, arguments);
+        logger$3.error.apply(logger$3.error, arguments);
         try {
             if (!err && !(msg instanceof Error)) {
                 msg = new Error(msg);
             }
             this.getConfig('error_reporter')(msg, err);
         } catch(err) {
-            logger$2.error(err);
+            logger$3.error(err);
         }
     };
 
@@ -23580,7 +24331,7 @@
         var configValue = this.getConfig('record_min_ms');
 
         if (configValue > MAX_VALUE_FOR_MIN_RECORDING_MS) {
-            logger$2.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
+            logger$3.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
             return MAX_VALUE_FOR_MIN_RECORDING_MS;
         }
 
@@ -23743,7 +24494,7 @@
             .catch(this.handleError.bind(this));
     };
 
-    var logger$1 = console_with_prefix('recorder');
+    var logger$2 = console_with_prefix('recorder');
 
     /**
      * Recorder API: bundles rrweb and and exposes methods to start and stop recordings.
@@ -23759,7 +24510,7 @@
          */
         this.recordingRegistry = new RecordingRegistry({
             mixpanelInstance: this.mixpanelInstance,
-            errorReporter: logger$1.error,
+            errorReporter: logger$2.error,
             sharedLockStorage: sharedLockStorage
         });
         this._flushInactivePromise = this.recordingRegistry.flushInactiveRecordings();
@@ -23771,17 +24522,17 @@
     MixpanelRecorder.prototype.startRecording = function(options) {
         options = options || {};
         if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
-            logger$1.log('Recording already in progress, skipping startRecording.');
+            logger$2.log('Recording already in progress, skipping startRecording.');
             return;
         }
 
         var onIdleTimeout = function () {
-            logger$1.log('Idle timeout reached, restarting recording.');
+            logger$2.log('Idle timeout reached, restarting recording.');
             this.resetRecording();
         }.bind(this);
 
         var onMaxLengthReached = function () {
-            logger$1.log('Max recording length reached, stopping recording.');
+            logger$2.log('Max recording length reached, stopping recording.');
             this.resetRecording();
         }.bind(this);
 
@@ -23851,7 +24602,7 @@
                 } else if (startNewIfInactive) {
                     return this.startRecording({shouldStopBatcher: false});
                 } else {
-                    logger$1.log('No resumable recording found.');
+                    logger$2.log('No resumable recording found.');
                     return null;
                 }
             }.bind(this));
@@ -23863,8 +24614,12 @@
         this.startRecording({shouldStopBatcher: true});
     };
 
+    MixpanelRecorder.prototype.isRecording = function () {
+        return this.activeRecording && !this.activeRecording.isRrwebStopped();
+    };
+
     MixpanelRecorder.prototype.getActiveReplayId = function () {
-        if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
+        if (this.isRecording()) {
             return this.activeRecording.replayId;
         } else {
             return null;
@@ -24368,53 +25123,6 @@
     var logicExports = requireLogic();
     var jsonLogic = /*@__PURE__*/getDefaultExportFromCjs(logicExports);
 
-    /**
-     * Shared helper to recursively lowercase strings in nested structures
-     * @param {*} obj - Value to process
-     * @param {boolean} lowercaseKeys - Whether to lowercase object keys
-     * @returns {*} Processed value with lowercased strings
-     */
-    var lowercaseJson = function(obj, lowercaseKeys) {
-        if (obj === null || obj === undefined) {
-            return obj;
-        } else if (typeof obj === 'string') {
-            return obj.toLowerCase();
-        } else if (Array.isArray(obj)) {
-            return obj.map(function(item) {
-                return lowercaseJson(item, lowercaseKeys);
-            });
-        } else if (obj === Object(obj)) {
-            var result = {};
-            for (var key in obj) {
-                if (obj.hasOwnProperty(key)) {
-                    var newKey = lowercaseKeys && typeof key === 'string' ? key.toLowerCase() : key;
-                    result[newKey] = lowercaseJson(obj[key], lowercaseKeys);
-                }
-            }
-            return result;
-        } else {
-            return obj;
-        }
-    };
-
-    /**
-     * Lowercase all string keys and values in a nested structure
-     * @param {*} val - Value to process
-     * @returns {*} Processed value with lowercased strings
-     */
-    var lowercaseKeysAndValues = function(val) {
-        return lowercaseJson(val, true);
-    };
-
-    /**
-     * Lowercase only leaf node string values in a nested structure (keys unchanged)
-     * @param {*} val - Value to process
-     * @returns {*} Processed value with lowercased leaf strings
-     */
-    var lowercaseOnlyLeafNodes = function(val) {
-        return lowercaseJson(val, false);
-    };
-
     /**
      * Check if an event matches the given criteria
      * @param {string} eventName - The name of the event being checked
@@ -24438,13 +25146,8 @@
 
         if (propertyFilters && !_.isEmptyObject(propertyFilters)) {
             try {
-                // Lowercase all keys and values in event properties for case-insensitive matching
-                var lowercasedProperties = lowercaseKeysAndValues(properties || {});
-
-                // Lowercase only leaf nodes in JsonLogic filters (keep operators intact)
-                var lowercasedFilters = lowercaseOnlyLeafNodes(propertyFilters);
-
-                filtersMatch = jsonLogic.apply(lowercasedFilters, lowercasedProperties);
+                // Use properties as-is for case-sensitive matching
+                filtersMatch = jsonLogic.apply(propertyFilters, properties || {});
             } catch (error) {
                 return {
                     matches: false,
@@ -24564,7 +25267,7 @@
             observer.observe(shadowRoot, this.observerConfig);
             this.shadowObservers.push(observer);
         } catch (e) {
-            logger$3.critical('Error while observing shadow root', e);
+            logger$5.critical('Error while observing shadow root', e);
         }
     };
 
@@ -24575,7 +25278,7 @@
         }
 
         if (!weakSetSupported()) {
-            logger$3.critical('Shadow DOM observation unavailable: WeakSet not supported');
+            logger$5.critical('Shadow DOM observation unavailable: WeakSet not supported');
             return;
         }
 
@@ -24591,7 +25294,7 @@
             try {
                 this.shadowObservers[i].disconnect();
             } catch (e) {
-                logger$3.critical('Error while disconnecting shadow DOM observer', e);
+                logger$5.critical('Error while disconnecting shadow DOM observer', e);
             }
         }
         this.shadowObservers = [];
@@ -24779,7 +25482,7 @@
 
                 this.mutationObserver.observe(document.body || document.documentElement, MUTATION_OBSERVER_CONFIG);
             } catch (e) {
-                logger$3.critical('Error while setting up mutation observer', e);
+                logger$5.critical('Error while setting up mutation observer', e);
             }
         }
 
@@ -24794,7 +25497,7 @@
                 );
                 this.shadowDOMObserver.start();
             } catch (e) {
-                logger$3.critical('Error while setting up shadow DOM observer', e);
+                logger$5.critical('Error while setting up shadow DOM observer', e);
                 this.shadowDOMObserver = null;
             }
         }
@@ -24821,7 +25524,7 @@
             try {
                 listener.target.removeEventListener(listener.event, listener.handler, listener.options);
             } catch (e) {
-                logger$3.critical('Error while removing event listener', e);
+                logger$5.critical('Error while removing event listener', e);
             }
         }
         this.eventListeners = [];
@@ -24830,7 +25533,7 @@
             try {
                 this.mutationObserver.disconnect();
             } catch (e) {
-                logger$3.critical('Error while disconnecting mutation observer', e);
+                logger$5.critical('Error while disconnecting mutation observer', e);
             }
             this.mutationObserver = null;
         }
@@ -24839,7 +25542,7 @@
             try {
                 this.shadowDOMObserver.stop();
             } catch (e) {
-                logger$3.critical('Error while stopping shadow DOM observer', e);
+                logger$5.critical('Error while stopping shadow DOM observer', e);
             }
             this.shadowDOMObserver = null;
         }
@@ -24917,7 +25620,7 @@
 
     Autocapture.prototype.init = function() {
         if (!minDOMApisSupported()) {
-            logger$3.critical('Autocapture unavailable: missing required DOM APIs');
+            logger$5.critical('Autocapture unavailable: missing required DOM APIs');
             return;
         }
         this.initPageListeners();
@@ -24949,27 +25652,15 @@
     };
 
     Autocapture.prototype.currentUrlBlocked = function() {
-        var i;
         var currentUrl = _.info.currentUrl();
 
         var allowUrlRegexes = this.getConfig(CONFIG_ALLOW_URL_REGEXES) || [];
         if (allowUrlRegexes.length) {
             // we're using an allowlist, only track if current URL matches
-            var allowed = false;
-            for (i = 0; i < allowUrlRegexes.length; i++) {
-                var allowRegex = allowUrlRegexes[i];
-                try {
-                    if (currentUrl.match(allowRegex)) {
-                        allowed = true;
-                        break;
-                    }
-                } catch (err) {
-                    logger$3.critical('Error while checking block URL regex: ' + allowRegex, err);
-                    return true;
-                }
-            }
-            if (!allowed) {
-                // wasn't allowed by any regex
+            try {
+                return !urlMatchesRegexList(currentUrl, allowUrlRegexes);
+            } catch (err) {
+                logger$5.critical('Error while checking block URL regexes: ', err);
                 return true;
             }
         }
@@ -24979,17 +25670,12 @@
             return false;
         }
 
-        for (i = 0; i < blockUrlRegexes.length; i++) {
-            try {
-                if (currentUrl.match(blockUrlRegexes[i])) {
-                    return true;
-                }
-            } catch (err) {
-                logger$3.critical('Error while checking block URL regex: ' + blockUrlRegexes[i], err);
-                return true;
-            }
+        try {
+            return urlMatchesRegexList(currentUrl, blockUrlRegexes);
+        } catch (err) {
+            logger$5.critical('Error while checking block URL regexes: ', err);
+            return true;
         }
-        return false;
     };
 
     Autocapture.prototype.pageviewTrackingConfig = function() {
@@ -25125,7 +25811,7 @@
             return;
         }
 
-        logger$3.log('Initializing scroll depth tracking');
+        logger$5.log('Initializing scroll depth tracking');
 
         this.maxScrollViewDepth = Math.max(document$1.documentElement.clientHeight, win.innerHeight || 0);
 
@@ -25151,7 +25837,7 @@
         if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.get_config('record_heatmap_data')) {
             return;
         }
-        logger$3.log('Initializing click tracking');
+        logger$5.log('Initializing click tracking');
 
         this.listenerClick = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.is_recording_heatmap_data()) {
@@ -25170,7 +25856,7 @@
             return;
         }
 
-        logger$3.log('Initializing dead click tracking');
+        logger$5.log('Initializing dead click tracking');
         if (!this._deadClickTracker) {
             this._deadClickTracker = new DeadClickTracker(function(deadClickEvent) {
                 this.trackDomEvent(deadClickEvent, MP_EV_DEAD_CLICK);
@@ -25204,7 +25890,7 @@
         if (!this.getConfig(CONFIG_TRACK_INPUT)) {
             return;
         }
-        logger$3.log('Initializing input tracking');
+        logger$5.log('Initializing input tracking');
 
         this.listenerChange = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_INPUT)) {
@@ -25221,7 +25907,7 @@
         if (!this.pageviewTrackingConfig()) {
             return;
         }
-        logger$3.log('Initializing pageview tracking');
+        logger$5.log('Initializing pageview tracking');
 
         var previousTrackedUrl = '';
         var tracked = false;
@@ -25256,7 +25942,7 @@
                 }
                 if (didPathChange) {
                     this.lastScrollCheckpoint = 0;
-                    logger$3.log('Path change: re-initializing scroll depth checkpoints');
+                    logger$5.log('Path change: re-initializing scroll depth checkpoints');
                 }
             }
         }.bind(this));
@@ -25271,7 +25957,7 @@
             return;
         }
 
-        logger$3.log('Initializing rage click tracking');
+        logger$5.log('Initializing rage click tracking');
         if (!this._rageClickTracker) {
             this._rageClickTracker = new RageClickTracker();
         }
@@ -25301,7 +25987,7 @@
         if (!this.getConfig(CONFIG_TRACK_SCROLL)) {
             return;
         }
-        logger$3.log('Initializing scroll tracking');
+        logger$5.log('Initializing scroll tracking');
         this.lastScrollCheckpoint = 0;
 
         var scrollTrackFunction = function() {
@@ -25338,7 +26024,7 @@
                     }
                 }
             } catch (err) {
-                logger$3.critical('Error while calculating scroll percentage', err);
+                logger$5.critical('Error while calculating scroll percentage', err);
             }
             if (shouldTrack) {
                 this.mp.track(MP_EV_SCROLL, props);
@@ -25356,7 +26042,7 @@
         if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
             return;
         }
-        logger$3.log('Initializing submit tracking');
+        logger$5.log('Initializing submit tracking');
 
         this.listenerSubmit = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
@@ -25378,7 +26064,7 @@
             return;
         }
 
-        logger$3.log('Initializing page visibility tracking.');
+        logger$5.log('Initializing page visibility tracking.');
         this._initScrollDepthTracking();
         var previousTrackedUrl = _.info.currentUrl();
 
@@ -25463,7 +26149,7 @@
         return win[TARGETING_GLOBAL_NAME];
     };
 
-    var logger = console_with_prefix('flags');
+    var logger$1 = console_with_prefix('flags');
     var FLAGS_CONFIG_KEY = 'flags';
 
     var CONFIG_CONTEXT = 'context';
@@ -25506,7 +26192,7 @@
 
     FeatureFlagManager.prototype.init = function() {
         if (!this.minApisSupported()) {
-            logger.critical('Feature Flags unavailable: missing minimum required APIs');
+            logger$1.critical('Feature Flags unavailable: missing minimum required APIs');
             return;
         }
 
@@ -25541,7 +26227,7 @@
 
     FeatureFlagManager.prototype.updateContext = function(newContext, options) {
         if (!this.isSystemEnabled()) {
-            logger.critical('Feature Flags not enabled, cannot update context');
+            logger$1.critical('Feature Flags not enabled, cannot update context');
             return Promise.resolve();
         }
 
@@ -25558,7 +26244,7 @@
 
     FeatureFlagManager.prototype.areFlagsReady = function() {
         if (!this.isSystemEnabled()) {
-            logger.error('Feature Flags not enabled');
+            logger$1.error('Feature Flags not enabled');
         }
         return !!this.flags;
     };
@@ -25571,7 +26257,7 @@
         var distinctId = this.getMpProperty('distinct_id');
         var deviceId = this.getMpProperty('$device_id');
         var traceparent = generateTraceparent();
-        logger.log('Fetching flags for distinct ID: ' + distinctId);
+        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();
@@ -25670,11 +26356,11 @@
                 this._loadTargetingIfNeeded();
             }.bind(this)).catch(function(error) {
                 this.markFetchComplete();
-                logger.error(error);
+                logger$1.error(error);
             }.bind(this));
         }.bind(this)).catch(function(error) {
             this.markFetchComplete();
-            logger.error(error);
+            logger$1.error(error);
         }.bind(this));
 
         return this.fetchPromise;
@@ -25682,7 +26368,7 @@
 
     FeatureFlagManager.prototype.markFetchComplete = function() {
         if (!this._fetchInProgressStartTime) {
-            logger.error('Fetch in progress started time not set, cannot mark fetch complete');
+            logger$1.error('Fetch in progress started time not set, cannot mark fetch complete');
             return;
         }
         this._fetchStartTime = this._fetchInProgressStartTime;
@@ -25704,7 +26390,7 @@
 
         if (hasPropertyFilters) {
             this.getTargeting().then(function() {
-                logger.log('targeting loaded for property filter evaluation');
+                logger$1.log('targeting loaded for property filter evaluation');
             });
         }
     };
@@ -25719,7 +26405,7 @@
             this.loadExtraBundle.bind(this),
             this.targetingSrc
         ).catch(function(error) {
-            logger.error('Failed to load targeting: ' + error);
+            logger$1.error('Failed to load targeting: ' + error);
         }.bind(this));
     };
 
@@ -25773,7 +26459,7 @@
 
             // If no targeting library and event has property filters, skip it
             if (!targeting && pendingEvent['property_filters'] && !_.isEmptyObject(pendingEvent['property_filters'])) {
-                logger.warn('Skipping event check for "' + flagKey + '" - property filters require targeting library');
+                logger$1.warn('Skipping event check for "' + flagKey + '" - property filters require targeting library');
                 return;
             }
 
@@ -25796,7 +26482,7 @@
             }
 
             if (matchResult.error) {
-                logger.error('Error checking first-time event for flag "' + flagKey + '": ' + matchResult.error);
+                logger$1.error('Error checking first-time event for flag "' + flagKey + '": ' + matchResult.error);
                 return;
             }
 
@@ -25804,7 +26490,7 @@
                 return;
             }
 
-            logger.log('First-time event matched for flag "' + flagKey + '": ' + eventName);
+            logger$1.log('First-time event matched for flag "' + flagKey + '": ' + eventName);
 
             var newVariant = {
                 'key': pendingEvent['pending_variant']['variant_key'],
@@ -25845,7 +26531,7 @@
             'first_time_event_hash': firstTimeEventHash
         };
 
-        logger.log('Recording first-time event for flag: ' + flagId);
+        logger$1.log('Recording first-time event for flag: ' + flagId);
 
         // Fire-and-forget POST request
         this.fetch.call(win, url, {
@@ -25858,130 +26544,446 @@
             'body': JSON.stringify(payload)
         }).catch(function(error) {
             // Silent failure - cohort sync will catch up
-            logger.error('Failed to record first-time event for flag ' + flagId + ': ' + error);
+            logger$1.error('Failed to record first-time event for flag ' + flagId + ': ' + error);
+        });
+    };
+
+    FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
+        if (!this.fetchPromise) {
+            return new Promise(function(resolve) {
+                logger$1.critical('Feature Flags not initialized');
+                resolve(fallback);
+            });
+        }
+
+        return this.fetchPromise.then(function() {
+            return this.getVariantSync(featureName, fallback);
+        }.bind(this)).catch(function(error) {
+            logger$1.error(error);
+            return fallback;
+        });
+    };
+
+    FeatureFlagManager.prototype.getVariantSync = function(featureName, fallback) {
+        if (!this.areFlagsReady()) {
+            logger$1.log('Flags not loaded yet');
+            return fallback;
+        }
+        var feature = this.flags.get(featureName);
+        if (!feature) {
+            logger$1.log('No flag found: "' + featureName + '"');
+            return fallback;
+        }
+        this.trackFeatureCheck(featureName, feature);
+        return feature;
+    };
+
+    FeatureFlagManager.prototype.getVariantValue = function(featureName, fallbackValue) {
+        return this.getVariant(featureName, {'value': fallbackValue}).then(function(feature) {
+            return feature['value'];
+        }).catch(function(error) {
+            logger$1.error(error);
+            return fallbackValue;
+        });
+    };
+
+    // TODO remove deprecated method
+    FeatureFlagManager.prototype.getFeatureData = function(featureName, fallbackValue) {
+        logger$1.critical('mixpanel.flags.get_feature_data() is deprecated and will be removed in a future release. Use mixpanel.flags.get_variant_value() instead.');
+        return this.getVariantValue(featureName, fallbackValue);
+    };
+
+    FeatureFlagManager.prototype.getVariantValueSync = function(featureName, fallbackValue) {
+        return this.getVariantSync(featureName, {'value': fallbackValue})['value'];
+    };
+
+    FeatureFlagManager.prototype.isEnabled = function(featureName, fallbackValue) {
+        return this.getVariantValue(featureName).then(function() {
+            return this.isEnabledSync(featureName, fallbackValue);
+        }.bind(this)).catch(function(error) {
+            logger$1.error(error);
+            return fallbackValue;
         });
     };
 
-    FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
-        if (!this.fetchPromise) {
-            return new Promise(function(resolve) {
-                logger.critical('Feature Flags not initialized');
-                resolve(fallback);
-            });
+    FeatureFlagManager.prototype.isEnabledSync = function(featureName, fallbackValue) {
+        fallbackValue = fallbackValue || false;
+        var val = this.getVariantValueSync(featureName, fallbackValue);
+        if (val !== true && val !== false) {
+            logger$1.error('Feature flag "' + featureName + '" value: ' + val + ' is not a boolean; returning fallback value: ' + fallbackValue);
+            val = fallbackValue;
+        }
+        return val;
+    };
+
+    FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature) {
+        if (this.trackedFeatures.has(featureName)) {
+            return;
+        }
+        this.trackedFeatures.add(featureName);
+
+        var trackingProperties = {
+            '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 latency (ms)': this._fetchLatency,
+            'Variant fetch traceparent': this._traceparent,
+        };
+
+        if (feature['experiment_id'] !== 'undefined') {
+            trackingProperties['$experiment_id'] = feature['experiment_id'];
+        }
+        if (feature['is_experiment_active'] !== 'undefined') {
+            trackingProperties['$is_experiment_active'] = feature['is_experiment_active'];
+        }
+        if (feature['is_qa_tester'] !== 'undefined') {
+            trackingProperties['$is_qa_tester'] = feature['is_qa_tester'];
+        }
+
+        this.track('$experiment_started', trackingProperties);
+    };
+
+    FeatureFlagManager.prototype.minApisSupported = function() {
+        return !!this.fetch &&
+          typeof Promise !== 'undefined' &&
+          typeof Map !== 'undefined' &&
+          typeof Set !== 'undefined';
+    };
+
+    safewrapClass(FeatureFlagManager);
+
+    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_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['update_context'] = FeatureFlagManager.prototype.updateContext;
+
+    // Deprecated method
+    FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
+
+    // Exports intended only for testing
+    FeatureFlagManager.prototype['getTargeting'] = FeatureFlagManager.prototype.getTargeting;
+
+    /* eslint camelcase: "off" */
+
+
+    var logger = console_with_prefix('recorder');
+
+    var IFRAME_HANDSHAKE_REQUEST  = 'mp_iframe_handshake_request';
+    var IFRAME_HANDSHAKE_RESPONSE = 'mp_iframe_handshake_response';
+
+
+    /**
+     * RecorderManager: manages session recording initialization, lifecycle and state
+     * @constructor
+     */
+    var RecorderManager = function(initOptions) {
+        // TODO - Passing in mixpanel instance as it is still needed for recorder creation
+        // but ideally we should be able to remove this dependency.
+        this.mixpanelInstance = initOptions.mixpanelInstance;
+
+        this.getMpConfig = initOptions.getConfigFunc;
+        this.getTabId = initOptions.getTabIdFunc;
+        this.reportError = initOptions.reportErrorFunc;
+        this.getDistinctId = initOptions.getDistinctIdFunc;
+        this.loadExtraBundle = initOptions.loadExtraBundle;
+        this.recorderSrc = initOptions.recorderSrc;
+        this.targetingSrc = initOptions.targetingSrc;
+        this.libBasePath = initOptions.libBasePath;
+
+        this._recorder = null;
+        this._parentReplayId = null;
+        this._parentFrameRetryInterval = null;
+    };
+
+    RecorderManager.prototype.shouldLoadRecorder = function() {
+        if (this.getMpConfig('disable_persistence')) {
+            console$1.log('Load recorder check skipped due to disable_persistence config');
+            return PromisePolyfill.resolve(false);
+        }
+
+        var recording_registry_idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
+        var tab_id = this.getTabId();
+        return recording_registry_idb.init()
+            .then(function () {
+                return recording_registry_idb.getAll();
+            })
+            .then(function (recordings) {
+                for (var i = 0; i < recordings.length; i++) {
+                    // if there are expired recordings in the registry, we should load the recorder to flush them
+                    // if there's a recording for this tab id, we should load the recorder to continue the recording
+                    if (isRecordingExpired(recordings[i]) || recordings[i]['tabId'] === tab_id) {
+                        return true;
+                    }
+                }
+                return false;
+            })
+            .catch(_.bind(function (err) {
+                this.reportError('Error checking recording registry', err);
+                return false;
+            }, this));
+    };
+
+    RecorderManager.prototype.checkAndStartSessionRecording = function(force_start, rate) {
+        if (!win['MutationObserver']) {
+            console$1.critical('Browser does not support MutationObserver; skipping session recording');
+            return PromisePolyfill.resolve();
+        }
+
+        var loadRecorder = _.bind(function(startNewIfInactive) {
+            return new PromisePolyfill(_.bind(function(resolve) {
+                var handleLoadedRecorder = safewrap(_.bind(function() {
+                    this._recorder = this._recorder || new win[RECORDER_GLOBAL_NAME](this.mixpanelInstance);
+                    this._recorder['resumeRecording'](startNewIfInactive);
+                    resolve();
+                }, this));
+
+                if (_.isUndefined(win[RECORDER_GLOBAL_NAME])) {
+                    var recorderSrc = this.recorderSrc || (this.libBasePath + RECORDER_FILENAME);
+                    this.loadExtraBundle(recorderSrc, handleLoadedRecorder);
+                } else {
+                    handleLoadedRecorder();
+                }
+            }, this));
+        }, this);
+
+        // Cross-origin iframe handling
+        var allowedOrigins = validateAllowedOrigins(this.getMpConfig('record_allowed_iframe_origins'), logger);
+        var isCrossOriginRecordingEnabled = allowedOrigins.length > 0;
+
+        if (isCrossOriginRecordingEnabled) {
+            // listen for handshake requests from their own child iframes (including nested)
+            this._setupParentFrameListener(allowedOrigins);
+
+            if (win.parent !== win) {
+                // also wait for parent's replay ID
+                this._setupChildFrameListener(allowedOrigins, loadRecorder);
+                this._sendParentFrameRequestWithRetry(allowedOrigins);
+                return PromisePolyfill.resolve();
+            }
+        }
+
+        /**
+         * If the user is sampled or start_session_recording is called, we always load the recorder since it's guaranteed a recording should start.
+         * Otherwise, if the recording registry has any records then it's likely there's a recording in progress or orphaned data that needs to be flushed.
+         */
+        var effective_rate = _.isUndefined(rate) ? this.getMpConfig('record_sessions_percent') : rate;
+        var is_sampled = effective_rate > 0 && Math.random() * 100 <= effective_rate;
+        if (force_start || is_sampled) {
+            return loadRecorder(true);
+        } else {
+            return this.shouldLoadRecorder()
+                .then(_.bind(function (shouldLoad) {
+                    if (shouldLoad) {
+                        return loadRecorder(false);
+                    }
+                    return PromisePolyfill.resolve();
+                }, this));
+        }
+    };
+
+    RecorderManager.prototype.isRecording = function() {
+        // Safety check: ensure isRecording method exists (older CDN builds may not have it)
+        if (!this._recorder || !_.isFunction(this._recorder['isRecording'])) {
+            return false;
+        }
+        try {
+            return this._recorder['isRecording']();
+        } catch (e) {
+            this.reportError('Error checking if recording is active', e);
+            return false;
         }
+    };
 
-        return this.fetchPromise.then(function() {
-            return this.getVariantSync(featureName, fallback);
-        }.bind(this)).catch(function(error) {
-            logger.error(error);
-            return fallback;
-        });
+    RecorderManager.prototype.startRecordingOnEvent = function(event_name, properties) {
+        var isRecording = this.isRecording();
+        var recordingTriggerEvents = this.getMpConfig('recording_event_triggers');
+
+        if (!isRecording && recordingTriggerEvents) {
+            var trigger = recordingTriggerEvents[event_name];
+            if (trigger && typeof trigger['percentage'] === 'number') {
+                var newRate = trigger['percentage'];
+                var propertyFilters = trigger['property_filters'];
+                if (propertyFilters && !_.isEmptyObject(propertyFilters)) {
+                    var targetingSrc = this.targetingSrc || (this.libBasePath + TARGETING_FILENAME);
+                    getTargetingPromise(this.loadExtraBundle, targetingSrc)
+                        .then(function(targeting) {
+                            try {
+                                var result = targeting['eventMatchesCriteria'](
+                                    event_name,
+                                    properties,
+                                    {
+                                        'event_name': event_name,
+                                        'property_filters': propertyFilters
+                                    }
+                                );
+                                if (result['matches']) {
+                                    this.checkAndStartSessionRecording(false, newRate);
+                                }
+                            } catch (err) {
+                                console$1.critical('Could not parse recording event trigger properties logic:', err);
+                            }
+                        }.bind(this)).catch(function(err) {
+                            console$1.critical('Failed to load targeting library:', err);
+                        });
+                } else {
+                    this.checkAndStartSessionRecording(false, newRate);
+                }
+            }
+        }
     };
 
-    FeatureFlagManager.prototype.getVariantSync = function(featureName, fallback) {
-        if (!this.areFlagsReady()) {
-            logger.log('Flags not loaded yet');
-            return fallback;
+    RecorderManager.prototype.stopSessionRecording = function() {
+        if (this._recorder) {
+            return this._recorder['stopRecording']();
         }
-        var feature = this.flags.get(featureName);
-        if (!feature) {
-            logger.log('No flag found: "' + featureName + '"');
-            return fallback;
+        return PromisePolyfill.resolve();
+    };
+
+    RecorderManager.prototype.pauseSessionRecording = function() {
+        if (this._recorder) {
+            return this._recorder['pauseRecording']();
         }
-        this.trackFeatureCheck(featureName, feature);
-        return feature;
+        return PromisePolyfill.resolve();
     };
 
-    FeatureFlagManager.prototype.getVariantValue = function(featureName, fallbackValue) {
-        return this.getVariant(featureName, {'value': fallbackValue}).then(function(feature) {
-            return feature['value'];
-        }).catch(function(error) {
-            logger.error(error);
-            return fallbackValue;
-        });
+    RecorderManager.prototype.resumeSessionRecording = function() {
+        if (this._recorder) {
+            return this._recorder['resumeRecording']();
+        }
+        return PromisePolyfill.resolve();
     };
 
-    // TODO remove deprecated method
-    FeatureFlagManager.prototype.getFeatureData = function(featureName, fallbackValue) {
-        logger.critical('mixpanel.flags.get_feature_data() is deprecated and will be removed in a future release. Use mixpanel.flags.get_variant_value() instead.');
-        return this.getVariantValue(featureName, fallbackValue);
+    RecorderManager.prototype.isRecordingHeatmapData = function() {
+        return this.getSessionReplayId() && this.getMpConfig('record_heatmap_data');
     };
 
-    FeatureFlagManager.prototype.getVariantValueSync = function(featureName, fallbackValue) {
-        return this.getVariantSync(featureName, {'value': fallbackValue})['value'];
+    RecorderManager.prototype.getSessionRecordingProperties = function() {
+        var props = {};
+        var replay_id = this.getSessionReplayId();
+        if (replay_id) {
+            props['$mp_replay_id'] = replay_id;
+        }
+        return props;
     };
 
-    FeatureFlagManager.prototype.isEnabled = function(featureName, fallbackValue) {
-        return this.getVariantValue(featureName).then(function() {
-            return this.isEnabledSync(featureName, fallbackValue);
-        }.bind(this)).catch(function(error) {
-            logger.error(error);
-            return fallbackValue;
-        });
+    RecorderManager.prototype.getSessionReplayUrl = function() {
+        var replay_url = null;
+        var replay_id = this.getSessionReplayId();
+        if (replay_id) {
+            var query_params = _.HTTPBuildQuery({
+                'replay_id': replay_id,
+                'distinct_id': this.getDistinctId(),
+                'token': this.getMpConfig('token')
+            });
+            replay_url = 'https://mixpanel.com/projects/replay-redirect?' + query_params;
+        }
+        return replay_url;
     };
 
-    FeatureFlagManager.prototype.isEnabledSync = function(featureName, fallbackValue) {
-        fallbackValue = fallbackValue || false;
-        var val = this.getVariantValueSync(featureName, fallbackValue);
-        if (val !== true && val !== false) {
-            logger.error('Feature flag "' + featureName + '" value: ' + val + ' is not a boolean; returning fallback value: ' + fallbackValue);
-            val = fallbackValue;
+    RecorderManager.prototype.getSessionReplayId = function() {
+        // Child iframe uses parent's replay ID
+        if (this._parentReplayId) {
+            return this._parentReplayId;
         }
-        return val;
+        var replay_id = null;
+        if (this._recorder) {
+            replay_id = this._recorder['replayId'];
+        }
+        return replay_id || null;
     };
 
-    FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature) {
-        if (this.trackedFeatures.has(featureName)) {
+    // "private" public method to reach into the recorder in test cases
+    RecorderManager.prototype.getRecorder = function() {
+        return this._recorder;
+    };
+
+    RecorderManager.prototype._setupChildFrameListener = function(allowedOrigins, loadRecorder) {
+        if (this._childFrameMessageHandler) {
             return;
         }
-        this.trackedFeatures.add(featureName);
-
-        var trackingProperties = {
-            '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 latency (ms)': this._fetchLatency,
-            'Variant fetch traceparent': this._traceparent,
+        var self = this;
+        this._childFrameMessageHandler = function(event) {
+            if (allowedOrigins.indexOf(event.origin) === -1) return;
+            var data = event.data;
+            if (data && data['type'] === IFRAME_HANDSHAKE_RESPONSE && data['token'] === self.getMpConfig('token') && data['replayId']) {
+                self._parentReplayId = data['replayId'];
+                if (data['distinctId']) {
+                    self.mixpanelInstance['identify'](data['distinctId']);
+                }
+                self._parentFrameRetryActive = false;
+                win.removeEventListener('message', self._childFrameMessageHandler);
+                self._childFrameMessageHandler = null;
+                loadRecorder(true);
+            }
         };
+        win.addEventListener('message', this._childFrameMessageHandler);
+    };
 
-        if (feature['experiment_id'] !== 'undefined') {
-            trackingProperties['$experiment_id'] = feature['experiment_id'];
-        }
-        if (feature['is_experiment_active'] !== 'undefined') {
-            trackingProperties['$is_experiment_active'] = feature['is_experiment_active'];
-        }
-        if (feature['is_qa_tester'] !== 'undefined') {
-            trackingProperties['$is_qa_tester'] = feature['is_qa_tester'];
+    RecorderManager.prototype._sendParentFrameRequest = function(allowedOrigins) {
+        var message = {};
+        message['type'] = IFRAME_HANDSHAKE_REQUEST;
+        message['token'] = this.getMpConfig('token');
+        for (var i = 0; i < allowedOrigins.length; i++) {
+            try {
+                win.parent.postMessage(message, allowedOrigins[i]);
+            } catch (e) {
+                // origin mismatch - ignore
+            }
         }
-
-        this.track('$experiment_started', trackingProperties);
     };
 
-    FeatureFlagManager.prototype.minApisSupported = function() {
-        return !!this.fetch &&
-          typeof Promise !== 'undefined' &&
-          typeof Map !== 'undefined' &&
-          typeof Set !== 'undefined';
-    };
+    RecorderManager.prototype._sendParentFrameRequestWithRetry = function(allowedOrigins) {
+        var self = this;
+        var maxRetries = 10;
+        var retryCount = 0;
+        var delay = 50;
+        this._parentFrameRetryActive = true;
 
-    safewrapClass(FeatureFlagManager);
+        this._sendParentFrameRequest(allowedOrigins);
 
-    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_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['update_context'] = FeatureFlagManager.prototype.updateContext;
+        function scheduleRetry() {
+            setTimeout(function() {
+                if (!self._parentFrameRetryActive || self._parentReplayId || ++retryCount >= maxRetries) {
+                    return;
+                }
+                self._sendParentFrameRequest(allowedOrigins);
+                delay *= 2;
+                scheduleRetry();
+            }, delay);
+        }
+        scheduleRetry();
+    };
 
-    // Deprecated method
-    FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
+    RecorderManager.prototype._setupParentFrameListener = function(allowedOrigins) {
+        if (this._parentFrameMessageHandler) {
+            return;
+        }
+        var self = this;
+        this._parentFrameMessageHandler = function(event) {
+            if (allowedOrigins.indexOf(event.origin) === -1) return;
+            var data = event.data;
+            if (data && data['type'] === IFRAME_HANDSHAKE_REQUEST && data['token'] === self.getMpConfig('token')) {
+                var replayId = self.getSessionReplayId();
+                if (replayId) {
+                    var response = {};
+                    response['type'] = IFRAME_HANDSHAKE_RESPONSE;
+                    response['token'] = self.getMpConfig('token');
+                    response['replayId'] = replayId;
+                    response['distinctId'] = self.getDistinctId();
+                    event.source.postMessage(response, event.origin);
+                }
+            }
+        };
+        win.addEventListener('message', this._parentFrameMessageHandler);
+    };
 
-    // Exports intended only for testing
-    FeatureFlagManager.prototype['getTargeting'] = FeatureFlagManager.prototype.getTargeting;
+    safewrapClass(RecorderManager);
 
     /* eslint camelcase: "off" */
 
@@ -27355,7 +28357,6 @@
     /** @const */ var SETTING_FALLBACK      = 'fallback';
     /** @const */ var SETTING_DISABLED      = 'disabled';
 
-
     /*
      * Dynamic... constants? Is that an oxymoron?
      */
@@ -27440,19 +28441,24 @@
         'batch_request_timeout_ms':          90000,
         'batch_autostart':                   true,
         'hooks':                             {},
+        'record_allowed_iframe_origins':     [],
         'record_block_class':                new RegExp('^(mp-block|fs-exclude|amp-block|rr-block|ph-no-capture)$'),
         'record_block_selector':             'img, video, audio',
         'record_canvas':                     false,
         'record_collect_fonts':              false,
         'record_console':                    true,
         'record_heatmap_data':               false,
+        'recording_event_triggers':          {},
         'record_idle_timeout_ms':            30 * 60 * 1000, // 30 minutes
         'record_mask_inputs':                true,
         'record_max_ms':                     MAX_RECORDING_MS,
         'record_min_ms':                     0,
+        'record_network':                    false,
+        'record_network_options':            {},
         'record_sessions_percent':           0,
-        'recorder_src':                      'https://cdn.mxpnl.com/libs/mixpanel-recorder.min.js',
-        'targeting_src':                     'https://cdn.mxpnl.com/libs/mixpanel-targeting.min.js',
+        'recorder_src':                      null,
+        'targeting_src':                     null,
+        'lib_base_path':                     'https://cdn.mxpnl.com/libs/',
         'remote_settings_mode':              SETTING_DISABLED // 'strict', 'fallback', 'disabled'
     };
 
@@ -27606,6 +28612,19 @@
             'callback_fn': ((name === PRIMARY_INSTANCE_NAME) ? name : PRIMARY_INSTANCE_NAME + '.' + name) + '._jsc'
         }));
 
+        this.recorderManager = new RecorderManager({
+            mixpanelInstance: this,
+            getConfigFunc: _.bind(this.get_config, this),
+            setConfigFunc: _.bind(this.set_config, this),
+            getTabIdFunc: _.bind(this.get_tab_id, this),
+            reportErrorFunc: _.bind(this.report_error, this),
+            getDistinctIdFunc: _.bind(this.get_distinct_id, this),
+            recorderSrc: this.get_config('recorder_src'),
+            targetingSrc: this.get_config('targeting_src'),
+            libBasePath: this.get_config('lib_base_path'),
+            loadExtraBundle: load_extra_bundle
+        });
+
         this['_jsc'] = NOOP_FUNC;
 
         this.__dom_loaded_queue = [];
@@ -27684,7 +28703,7 @@
             getPropertyFunc: _.bind(this.get_property, this),
             trackingFunc: _.bind(this.track, this),
             loadExtraBundle: load_extra_bundle,
-            targetingSrc: this.get_config('targeting_src')
+            targetingSrc: this.get_config('targeting_src') || (this.get_config('lib_base_path') + TARGETING_FILENAME)
         });
         this.flags.init();
         this['flags'] = this.flags;
@@ -27697,11 +28716,11 @@
         // Based on remote_settings_mode, fetch remote settings and then start session recording if applicable
         var mode = this.get_config('remote_settings_mode');
         if (mode === SETTING_STRICT || mode === SETTING_FALLBACK) {
-            this._fetch_remote_settings(mode).then(_.bind(function() {
-                this._check_and_start_session_recording();
+            this.__session_recording_init_promise = this._fetch_remote_settings(mode).then(_.bind(function() {
+                return this._check_and_start_session_recording();
             }, this));
         } else {
-            this._check_and_start_session_recording();
+            this.__session_recording_init_promise = this._check_and_start_session_recording();
         }
     };
 
@@ -27745,132 +28764,50 @@
         return this.tab_id || null;
     };
 
-    MixpanelLib.prototype._should_load_recorder = function () {
-        if (this.get_config('disable_persistence')) {
-            console$1.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()
-            .then(function () {
-                return recording_registry_idb.getAll();
-            })
-            .then(function (recordings) {
-                for (var i = 0; i < recordings.length; i++) {
-                    // if there are expired recordings in the registry, we should load the recorder to flush them
-                    // if there's a recording for this tab id, we should load the recorder to continue the recording
-                    if (isRecordingExpired(recordings[i]) || recordings[i]['tabId'] === tab_id) {
-                        return true;
-                    }
-                }
-                return false;
-            })
-            .catch(_.bind(function (err) {
-                this.report_error('Error checking recording registry', err);
-            }, this));
-    };
-
     MixpanelLib.prototype._check_and_start_session_recording = addOptOutCheckMixpanelLib(function(force_start) {
-        if (!win['MutationObserver']) {
-            console$1.critical('Browser does not support MutationObserver; skipping session recording');
-            return;
-        }
-
-        var loadRecorder = _.bind(function(startNewIfInactive) {
-            var handleLoadedRecorder = _.bind(function() {
-                this._recorder = this._recorder || new win[RECORDER_GLOBAL_NAME](this);
-                this._recorder['resumeRecording'](startNewIfInactive);
-            }, this);
-
-            if (_.isUndefined(win[RECORDER_GLOBAL_NAME])) {
-                load_extra_bundle(this.get_config('recorder_src'), handleLoadedRecorder);
-            } else {
-                handleLoadedRecorder();
-            }
-        }, this);
-
-        /**
-         * If the user is sampled or start_session_recording is called, we always load the recorder since it's guaranteed a recording should start.
-         * Otherwise, if the recording registry has any records then it's likely there's a recording in progress or orphaned data that needs to be flushed.
-         */
-        var is_sampled = this.get_config('record_sessions_percent') > 0 && Math.random() * 100 <= this.get_config('record_sessions_percent');
-        if (force_start || is_sampled) {
-            loadRecorder(true);
-        } else {
-            this._should_load_recorder()
-                .then(function (shouldLoad) {
-                    if (shouldLoad) {
-                        loadRecorder(false);
-                    }
-                });
-        }
+        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_session_recording = function () {
-        this._check_and_start_session_recording(true);
+        return this._check_and_start_session_recording(true);
     };
 
     MixpanelLib.prototype.stop_session_recording = function () {
-        if (this._recorder) {
-            return this._recorder['stopRecording']();
-        }
-        return Promise.resolve();
+        return this.recorderManager.stopSessionRecording();
     };
 
     MixpanelLib.prototype.pause_session_recording = function () {
-        if (this._recorder) {
-            return this._recorder['pauseRecording']();
-        }
-        return Promise.resolve();
+        return this.recorderManager.pauseSessionRecording();
     };
 
     MixpanelLib.prototype.resume_session_recording = function () {
-        if (this._recorder) {
-            return this._recorder['resumeRecording']();
-        }
-        return Promise.resolve();
+        return this.recorderManager.resumeSessionRecording();
     };
 
     MixpanelLib.prototype.is_recording_heatmap_data = function () {
-        return this._get_session_replay_id() && this.get_config('record_heatmap_data');
+        return this.recorderManager.isRecordingHeatmapData();
     };
 
     MixpanelLib.prototype.get_session_recording_properties = function () {
-        var props = {};
-        var replay_id = this._get_session_replay_id();
-        if (replay_id) {
-            props['$mp_replay_id'] = replay_id;
-        }
-        return props;
+        return this.recorderManager.getSessionRecordingProperties();
     };
 
     MixpanelLib.prototype.get_session_replay_url = function () {
-        var replay_url = null;
-        var replay_id = this._get_session_replay_id();
-        if (replay_id) {
-            var query_params = _.HTTPBuildQuery({
-                'replay_id': replay_id,
-                'distinct_id': this.get_distinct_id(),
-                'token': this.get_config('token')
-            });
-            replay_url = 'https://mixpanel.com/projects/replay-redirect?' + query_params;
-        }
-        return replay_url;
-    };
-
-    MixpanelLib.prototype._get_session_replay_id = function () {
-        var replay_id = null;
-        if (this._recorder) {
-            replay_id = this._recorder['replayId'];
-        }
-        return replay_id || null;
+        return this.recorderManager.getSessionReplayUrl();
     };
 
     // "private" public method to reach into the recorder in test cases
     MixpanelLib.prototype.__get_recorder = function () {
-        return this._recorder;
+        return this.recorderManager.getRecorder();
+    };
+
+    // "private" public method to get session recording init promise in test cases
+    MixpanelLib.prototype.__get_recording_init_promise = function () {
+        return this.__session_recording_init_promise;
     };
 
     // Private methods
@@ -28128,6 +29065,7 @@
     };
 
     MixpanelLib.prototype._fetch_remote_settings = function(mode) {
+        var self = this;
         var disableRecordingIfStrict = function() {
             if (mode === 'strict') {
                 self.set_config({'record_sessions_percent': 0});
@@ -28148,7 +29086,6 @@
         };
         var query_string = _.HTTPBuildQuery(request_params);
         var full_url = settings_endpoint + '?' + query_string;
-        var self = this;
 
         var abortController = new AbortController();
         var timeout_id = setTimeout(function() {
@@ -28340,6 +29277,34 @@
         this._execute_array([item]);
     };
 
+    /**
+     * Enables events on the Mixpanel object. If passed no arguments,
+     * this function enable tracking of all events. If passed an
+     * array of event names, those events will be enabled, but other
+     * existing disabled events will continue to be not tracked.
+     *
+     * @param {Array} [events] An array of event names to enable
+     */
+    MixpanelLib.prototype.enable = function(events) {
+        var keys, new_disabled_events, i, j;
+
+        if (typeof(events) === 'undefined') {
+            this._flags.disable_all_events = false;
+        } else {
+            keys = {};
+            new_disabled_events = [];
+            for (i = 0; i < events.length; i++) {
+                keys[events[i]] = true;
+            }
+            for (j = 0; j < this.__disabled_events.length; j++) {
+                if (!keys[this.__disabled_events[j]]) {
+                    new_disabled_events.push(this.__disabled_events[j]);
+                }
+            }
+            this.__disabled_events = new_disabled_events;
+        }
+    };
+
     /**
      * Disable events on the Mixpanel object. If passed no arguments,
      * this function disables tracking of any event. If passed an
@@ -28513,6 +29478,8 @@
             this.report_error('Invalid value for property_blacklist config: ' + property_blacklist);
         }
 
+        this._start_recording_on_event(event_name, properties);
+
         var data = {
             'event': event_name,
             'properties': properties
@@ -29721,6 +30688,7 @@
     // MixpanelLib Exports
     MixpanelLib.prototype['init']                               = MixpanelLib.prototype.init;
     MixpanelLib.prototype['reset']                              = MixpanelLib.prototype.reset;
+    MixpanelLib.prototype['enable']                             = MixpanelLib.prototype.enable;
     MixpanelLib.prototype['disable']                            = MixpanelLib.prototype.disable;
     MixpanelLib.prototype['time_event']                         = MixpanelLib.prototype.time_event;
     MixpanelLib.prototype['track']                              = MixpanelLib.prototype.track;
@@ -29764,6 +30732,7 @@
 
     // Exports intended only for testing
     MixpanelLib.prototype['__get_recorder']                     = MixpanelLib.prototype.__get_recorder;
+    MixpanelLib.prototype['__get_recording_init_promise']       = MixpanelLib.prototype.__get_recording_init_promise;
 
     // MixpanelPersistence Exports
     MixpanelPersistence.prototype['properties']            = MixpanelPersistence.prototype.properties;