mixpanel-browser 2.74.0 → 2.76.0

package/dist/mixpanel.umd.js

@@ -29,6 +29,19 @@
         win = window;
     }
 
+    var Config = {
+        DEBUG: false,
+        LIB_VERSION: '2.76.0'
+    };
+
+    // Window global names for async modules
+    var TARGETING_GLOBAL_NAME = '__mp_targeting';
+    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];
@@ -643,14 +656,16 @@
             return this.nodeMetaMap.get(n2) || null;
         };
         // removes the node from idNodeMap
-        // doesn't remove the node from nodeMetaMap
-        _proto.removeNodeFromMap = function removeNodeFromMap(n2) {
+        // if permanent is true, also removes from nodeMetaMap
+        _proto.removeNodeFromMap = function removeNodeFromMap(n2, permanent) {
             var _this = this;
+            if (permanent === void 0) permanent = false;
             var id = this.getId(n2);
             this.idNodeMap.delete(id);
+            if (permanent) this.nodeMetaMap.delete(n2);
             if (n2.childNodes) {
                 n2.childNodes.forEach(function(childNode) {
-                    return _this.removeNodeFromMap(childNode);
+                    return _this.removeNodeFromMap(childNode, permanent);
                 });
             }
         };
@@ -10392,6 +10407,15 @@
         _proto.generateId = function generateId() {
             return this.id++;
         };
+        _proto.remove = function remove(stylesheet) {
+            var id = this.styleIDMap.get(stylesheet);
+            if (id !== void 0) {
+                this.styleIDMap.delete(stylesheet);
+                this.idStyleMap.delete(id);
+                return true;
+            }
+            return false;
+        };
         return StyleSheetMirror;
     }();
     function getShadowHost(n2) {
@@ -10714,7 +10738,15 @@
                     }
                 };
                 while(_this.mapRemoves.length){
-                    _this.mirror.removeNodeFromMap(_this.mapRemoves.shift());
+                    var removedNode = _this.mapRemoves.shift();
+                    if (removedNode.nodeName === "IFRAME") {
+                        try {
+                            _this.iframeManager.removeIframe(removedNode);
+                        } catch (e2) {}
+                    } else {
+                        _this.stylesheetManager.cleanupStylesheetsForRemovedNode(removedNode);
+                    }
+                    _this.mirror.removeNodeFromMap(removedNode);
                 }
                 for(var _iterator = _create_for_of_iterator_helper_loose(_this.movedSet), _step; !(_step = _iterator()).done;){
                     var n2 = _step.value;
@@ -11088,6 +11120,9 @@
             this.shadowDomManager.reset();
             this.canvasManager.reset();
         };
+        _proto.getDoc = function getDoc() {
+            return this.doc;
+        };
         return MutationBuffer;
     }();
     function deepDelete(addsSet, n2) {
@@ -11188,6 +11223,14 @@
         });
         return observer;
     }
+    function removeMutationBufferForDoc(doc) {
+        for(var i2 = mutationBuffers.length - 1; i2 >= 0; i2--){
+            var buffer = mutationBuffers[i2];
+            if (buffer.getDoc() === doc) {
+                mutationBuffers.splice(i2, 1);
+            }
+        }
+    }
     function initMoveObserver(param) {
         var mousemoveCb = param.mousemoveCb, sampling = param.sampling, doc = param.doc, mirror2 = param.mirror;
         if (sampling.mousemove === false) {
@@ -12203,6 +12246,8 @@
             __publicField$1(this, "crossOriginIframeMirror", new CrossOriginIframeMirror(genId));
             __publicField$1(this, "crossOriginIframeStyleMirror");
             __publicField$1(this, "crossOriginIframeRootIdMap", /* @__PURE__ */ new WeakMap());
+            __publicField$1(this, "iframeContentDocumentMap", /* @__PURE__ */ new WeakMap());
+            __publicField$1(this, "iframeObserverCleanupMap", /* @__PURE__ */ new WeakMap());
             __publicField$1(this, "mirror");
             __publicField$1(this, "mutationCb");
             __publicField$1(this, "wrappedEmit");
@@ -12224,6 +12269,31 @@
             this.iframes.set(iframeEl, true);
             if (iframeEl.contentWindow) this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);
         };
+        _proto.getIframeContentDocument = function getIframeContentDocument(iframeEl) {
+            return this.iframeContentDocumentMap.get(iframeEl);
+        };
+        _proto.setObserverCleanup = function setObserverCleanup(iframeEl, cleanup) {
+            this.iframeObserverCleanupMap.set(iframeEl, cleanup);
+        };
+        _proto.getObserverCleanup = function getObserverCleanup(iframeEl) {
+            return this.iframeObserverCleanupMap.get(iframeEl);
+        };
+        _proto.removeIframe = function removeIframe(iframeEl) {
+            var storedDoc = this.iframeContentDocumentMap.get(iframeEl);
+            if (storedDoc) {
+                this.stylesheetManager.cleanupStylesheetsForRemovedNode(storedDoc);
+                this.mirror.removeNodeFromMap(storedDoc, true);
+            }
+            this.iframes.delete(iframeEl);
+            this.iframeContentDocumentMap.delete(iframeEl);
+            var observerCleanup = this.iframeObserverCleanupMap.get(iframeEl);
+            if (observerCleanup) {
+                try {
+                    observerCleanup();
+                } catch (e2) {}
+                this.iframeObserverCleanupMap.delete(iframeEl);
+            }
+        };
         _proto.addLoadListener = function addLoadListener(cb) {
             this.loadListener = cb;
         };
@@ -12242,6 +12312,9 @@
                 attributes: [],
                 isAttachIframe: true
             });
+            if (iframeEl.contentDocument) {
+                this.iframeContentDocumentMap.set(iframeEl, iframeEl.contentDocument);
+            }
             if (this.recordCrossOriginIframes) (_a2 = iframeEl.contentWindow) == null ? void 0 : _a2.addEventListener("message", this.handleMessage.bind(this));
             (_b = this.loadListener) == null ? void 0 : _b.call(this, iframeEl);
             if (iframeEl.contentDocument && iframeEl.contentDocument.adoptedStyleSheets && iframeEl.contentDocument.adoptedStyleSheets.length > 0) this.stylesheetManager.adoptStyleSheets(iframeEl.contentDocument.adoptedStyleSheets, this.mirror.getId(iframeEl.contentDocument));
@@ -13154,6 +13227,41 @@
             this.styleMirror.reset();
             this.trackedLinkElements = /* @__PURE__ */ new WeakSet();
         };
+        /**
+       * Cleans up stylesheets associated with a removed node.
+       *
+       * @param removedNode - The node that was removed from the DOM.
+       */ _proto.cleanupStylesheetsForRemovedNode = function cleanupStylesheetsForRemovedNode(removedNode) {
+            var _this = this;
+            try {
+                if (removedNode.nodeType === Node.DOCUMENT_NODE) {
+                    var doc = removedNode;
+                    if (doc.adoptedStyleSheets) {
+                        for(var _iterator = _create_for_of_iterator_helper_loose(doc.adoptedStyleSheets), _step; !(_step = _iterator()).done;){
+                            var sheet = _step.value;
+                            this.styleMirror.remove(sheet);
+                        }
+                    }
+                }
+                if (removedNode.nodeName === "STYLE") {
+                    var styleEl = removedNode;
+                    if (styleEl.sheet) {
+                        this.styleMirror.remove(styleEl.sheet);
+                    }
+                }
+                if (removedNode.nodeName === "LINK" && removedNode.rel === "stylesheet") {
+                    var linkEl = removedNode;
+                    if (linkEl.sheet) {
+                        this.styleMirror.remove(linkEl.sheet);
+                    }
+                }
+                if (removedNode.childNodes) {
+                    removedNode.childNodes.forEach(function(child) {
+                        _this.cleanupStylesheetsForRemovedNode(child);
+                    });
+                }
+            } catch (e2) {}
+        };
         // TODO: take snapshot on stylesheet reload by applying event listener
         _proto.trackStylesheetInLinkElement = function trackStylesheetInLinkElement(_linkEl) {};
         return StylesheetManager;
@@ -13608,7 +13716,23 @@
             };
             iframeManager.addLoadListener(function(iframeEl) {
                 try {
-                    handlers.push(observe(iframeEl.contentDocument));
+                    var iframeDoc = iframeEl.contentDocument;
+                    var iframeHandler = observe(iframeDoc);
+                    handlers.push(iframeHandler);
+                    var existingCleanup = iframeManager.getObserverCleanup(iframeEl);
+                    iframeManager.setObserverCleanup(iframeEl, function() {
+                        if (existingCleanup) {
+                            try {
+                                existingCleanup();
+                            } catch (e2) {}
+                        }
+                        try {
+                            iframeHandler();
+                            var idx = handlers.indexOf(iframeHandler);
+                            if (idx !== -1) handlers.splice(idx, 1);
+                            removeMutationBufferForDoc(iframeDoc);
+                        } catch (e2) {}
+                    });
                 } catch (error) {
                     console.warn(error);
                 }
@@ -13865,7 +13989,7 @@
         }
         return classMatchesRegex(index.parentNode(node2), regex);
     }
-    function getDefaultExportFromCjs(x2) {
+    function getDefaultExportFromCjs$3(x2) {
         return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
     }
     function getAugmentedNamespace(n) {
@@ -17980,7 +18104,7 @@
     LazyResult2.registerPostcss(postcss);
     var postcss_1 = postcss;
     postcss.default = postcss;
-    var postcss$1 = /* @__PURE__ */ getDefaultExportFromCjs(postcss_1);
+    var postcss$1 = /* @__PURE__ */ getDefaultExportFromCjs$3(postcss_1);
     postcss$1.stringify;
     postcss$1.fromJSON;
     postcss$1.plugin;
@@ -18017,7 +18141,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() {};
@@ -18434,7 +18558,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++){
@@ -18855,11 +18979,6 @@
         PromisePolyfill = NpoPromise;
     }
 
-    var Config = {
-        DEBUG: false,
-        LIB_VERSION: '2.74.0'
-    };
-
     /* eslint camelcase: "off", eqeqeq: "off" */
 
     // Maximum allowed session recording length
@@ -19063,15 +19182,8 @@
         return toString.call(obj) === '[object Array]';
     };
 
-    // from a comment on http://dbj.org/dbj/?p=286
-    // fails on only one very rare and deliberate custom object:
-    // var bomb = { toString : undefined, valueOf: function(o) { return "function BOMBA!"; }};
     _.isFunction = function(f) {
-        try {
-            return /^\s*\bfunction\b/.test(f);
-        } catch (x) {
-            return false;
-        }
+        return typeof f === 'function';
     };
 
     _.isArguments = function(obj) {
@@ -20598,6 +20710,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;
@@ -21069,7 +21192,7 @@
         };
     }
 
-    var logger$6 = console_with_prefix('lock');
+    var logger$7 = console_with_prefix('lock');
 
     /**
      * SharedLock: a mutex built on HTML5 localStorage, to ensure that only one browser
@@ -21121,7 +21244,7 @@
 
             var delay = function(cb) {
                 if (new Date().getTime() - startTime > timeoutMS) {
-                    logger$6.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
+                    logger$7.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
                     storage.removeItem(keyZ);
                     storage.removeItem(keyY);
                     loop();
@@ -21268,7 +21391,7 @@
         }, this));
     };
 
-    var logger$5 = console_with_prefix('batch');
+    var logger$6 = console_with_prefix('batch');
 
     /**
      * RequestQueue: queue for batching API requests with localStorage backup for retries.
@@ -21297,7 +21420,7 @@
                 timeoutMS: options.sharedLockTimeoutMS,
             });
         }
-        this.reportError = options.errorReporter || _.bind(logger$5.error, logger$5);
+        this.reportError = options.errorReporter || _.bind(logger$6.error, logger$6);
 
         this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios
 
@@ -21630,7 +21753,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$5 = console_with_prefix('batch');
 
     /**
      * RequestBatcher: manages the queueing, flushing, retry etc of requests of one
@@ -21758,7 +21881,7 @@
      */
     RequestBatcher.prototype.flush = function(options) {
         if (this.requestInProgress) {
-            logger$4.log('Flush: Request already in progress');
+            logger$5.log('Flush: Request already in progress');
             return PromisePolyfill.resolve();
         }
 
@@ -21935,7 +22058,7 @@
                 if (options.unloading) {
                     requestOptions.transport = 'sendBeacon';
                 }
-                logger$4.log('MIXPANEL REQUEST:', dataForRequest);
+                logger$5.log('MIXPANEL REQUEST:', dataForRequest);
                 return this.sendRequestPromise(dataForRequest, requestOptions).then(batchSendCallback);
             }, this))
             .catch(_.bind(function(err) {
@@ -21948,7 +22071,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$5.error.apply(logger$5.error, arguments);
         if (this.errorReporter) {
             try {
                 if (!(err instanceof Error)) {
@@ -21956,7 +22079,7 @@
                 }
                 this.errorReporter(msg, err);
             } catch(err) {
-                logger$4.error(err);
+                logger$5.error(err);
             }
         }
     };
@@ -22078,7 +22201,7 @@
 
     var MAX_DEPTH = 5;
 
-    var logger$3 = console_with_prefix('autocapture');
+    var logger$4 = console_with_prefix('autocapture');
 
 
     function getClasses(el) {
@@ -22342,7 +22465,7 @@
                     return false;
                 }
             } catch (err) {
-                logger$3.critical('Error while checking element in allowElementCallback', err);
+                logger$4.critical('Error while checking element in allowElementCallback', err);
                 return false;
             }
         }
@@ -22359,7 +22482,7 @@
                     return true;
                 }
             } catch (err) {
-                logger$3.critical('Error while checking selector: ' + sel, err);
+                logger$4.critical('Error while checking selector: ' + sel, err);
             }
         }
         return false;
@@ -22374,7 +22497,7 @@
                     return true;
                 }
             } catch (err) {
-                logger$3.critical('Error while checking element in blockElementCallback', err);
+                logger$4.critical('Error while checking element in blockElementCallback', err);
                 return true;
             }
         }
@@ -22388,7 +22511,7 @@
                         return true;
                     }
                 } catch (err) {
-                    logger$3.critical('Error while checking selector: ' + sel, err);
+                    logger$4.critical('Error while checking selector: ' + sel, err);
                 }
             }
         }
@@ -22936,173 +23059,822 @@
     }
 
     /**
-     * @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$3 = 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$3.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$3.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;
+    /**
+     * 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;
         }
-        var userId = this._mixpanel.get_property('$user_id');
-        if (userId) {
-            userIdInfo['$user_id'] = userId;
+
+        return recordHeaders[type].includes(headerName.toLowerCase());
+    }
+
+    /**
+     * 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 userIdInfo;
-    };
 
-    SessionRecording.prototype.unloadPersistedData = function () {
-        this.batcher.stop();
+        return urlMatchesRegexList(url, recordBodyUrls[type]);
+    }
 
-        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);
+    function tryReadXHRBody(body) {
+        if (body === null || body === undefined) {
+            return null;
+        }
+
+        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 this.batcher.flush()
-                .then(function () {
-                    return this.queueStorage.removeItem(this.batcherKey);
-                }.bind(this));
-        }.bind(this));
-    };
+        return truncateBody(result);
+    }
 
-    SessionRecording.prototype.getConfig = function(configVar) {
+    /**
+     * @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$3.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$3.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$3.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$3.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$3.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$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
+    };
+
+    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);
     };
 
@@ -23168,6 +23940,29 @@
 
         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
+                    }
+                })
+            );
+        }
+
         try {
             this._stopRecording = this._rrwebRecord({
                 'emit': function (ev) {
@@ -23206,15 +24001,7 @@
                 '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);
@@ -23329,6 +24116,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.
@@ -23348,7 +24139,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') + ':'),
@@ -23749,8 +24540,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;
@@ -23765,7 +24560,538 @@
         }
     });
 
-    win['__mp_recorder'] = MixpanelRecorder;
+    win[RECORDER_GLOBAL_NAME] = MixpanelRecorder;
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    var logic$1 = {exports: {}};
+
+    /* globals define,module */
+    var logic = logic$1.exports;
+
+    var hasRequiredLogic;
+
+    function requireLogic () {
+    	if (hasRequiredLogic) return logic$1.exports;
+    	hasRequiredLogic = 1;
+    	(function (module, exports) {
+    (function(root, factory) {
+    		  {
+    		    module.exports = factory();
+    		  }
+    		}(logic, function() {
+    		  /* globals console:false */
+
+    		  if ( ! Array.isArray) {
+    		    Array.isArray = function(arg) {
+    		      return Object.prototype.toString.call(arg) === "[object Array]";
+    		    };
+    		  }
+
+    		  /**
+    		   * Return an array that contains no duplicates (original not modified)
+    		   * @param  {array} array   Original reference array
+    		   * @return {array}         New array with no duplicates
+    		   */
+    		  function arrayUnique(array) {
+    		    var a = [];
+    		    for (var i=0, l=array.length; i<l; i++) {
+    		      if (a.indexOf(array[i]) === -1) {
+    		        a.push(array[i]);
+    		      }
+    		    }
+    		    return a;
+    		  }
+
+    		  var jsonLogic = {};
+    		  var operations = {
+    		    "==": function(a, b) {
+    		      return a == b;
+    		    },
+    		    "===": function(a, b) {
+    		      return a === b;
+    		    },
+    		    "!=": function(a, b) {
+    		      return a != b;
+    		    },
+    		    "!==": function(a, b) {
+    		      return a !== b;
+    		    },
+    		    ">": function(a, b) {
+    		      return a > b;
+    		    },
+    		    ">=": function(a, b) {
+    		      return a >= b;
+    		    },
+    		    "<": function(a, b, c) {
+    		      return (c === undefined) ? a < b : (a < b) && (b < c);
+    		    },
+    		    "<=": function(a, b, c) {
+    		      return (c === undefined) ? a <= b : (a <= b) && (b <= c);
+    		    },
+    		    "!!": function(a) {
+    		      return jsonLogic.truthy(a);
+    		    },
+    		    "!": function(a) {
+    		      return !jsonLogic.truthy(a);
+    		    },
+    		    "%": function(a, b) {
+    		      return a % b;
+    		    },
+    		    "log": function(a) {
+    		      console.log(a); return a;
+    		    },
+    		    "in": function(a, b) {
+    		      if (!b || typeof b.indexOf === "undefined") return false;
+    		      return (b.indexOf(a) !== -1);
+    		    },
+    		    "cat": function() {
+    		      return Array.prototype.join.call(arguments, "");
+    		    },
+    		    "substr": function(source, start, end) {
+    		      if (end < 0) {
+    		        // JavaScript doesn't support negative end, this emulates PHP behavior
+    		        var temp = String(source).substr(start);
+    		        return temp.substr(0, temp.length + end);
+    		      }
+    		      return String(source).substr(start, end);
+    		    },
+    		    "+": function() {
+    		      return Array.prototype.reduce.call(arguments, function(a, b) {
+    		        return parseFloat(a, 10) + parseFloat(b, 10);
+    		      }, 0);
+    		    },
+    		    "*": function() {
+    		      return Array.prototype.reduce.call(arguments, function(a, b) {
+    		        return parseFloat(a, 10) * parseFloat(b, 10);
+    		      });
+    		    },
+    		    "-": function(a, b) {
+    		      if (b === undefined) {
+    		        return -a;
+    		      } else {
+    		        return a - b;
+    		      }
+    		    },
+    		    "/": function(a, b) {
+    		      return a / b;
+    		    },
+    		    "min": function() {
+    		      return Math.min.apply(this, arguments);
+    		    },
+    		    "max": function() {
+    		      return Math.max.apply(this, arguments);
+    		    },
+    		    "merge": function() {
+    		      return Array.prototype.reduce.call(arguments, function(a, b) {
+    		        return a.concat(b);
+    		      }, []);
+    		    },
+    		    "var": function(a, b) {
+    		      var not_found = (b === undefined) ? null : b;
+    		      var data = this;
+    		      if (typeof a === "undefined" || a==="" || a===null) {
+    		        return data;
+    		      }
+    		      var sub_props = String(a).split(".");
+    		      for (var i = 0; i < sub_props.length; i++) {
+    		        if (data === null || data === undefined) {
+    		          return not_found;
+    		        }
+    		        // Descending into data
+    		        data = data[sub_props[i]];
+    		        if (data === undefined) {
+    		          return not_found;
+    		        }
+    		      }
+    		      return data;
+    		    },
+    		    "missing": function() {
+    		      /*
+    		      Missing can receive many keys as many arguments, like {"missing:[1,2]}
+    		      Missing can also receive *one* argument that is an array of keys,
+    		      which typically happens if it's actually acting on the output of another command
+    		      (like 'if' or 'merge')
+    		      */
+
+    		      var missing = [];
+    		      var keys = Array.isArray(arguments[0]) ? arguments[0] : arguments;
+
+    		      for (var i = 0; i < keys.length; i++) {
+    		        var key = keys[i];
+    		        var value = jsonLogic.apply({"var": key}, this);
+    		        if (value === null || value === "") {
+    		          missing.push(key);
+    		        }
+    		      }
+
+    		      return missing;
+    		    },
+    		    "missing_some": function(need_count, options) {
+    		      // missing_some takes two arguments, how many (minimum) items must be present, and an array of keys (just like 'missing') to check for presence.
+    		      var are_missing = jsonLogic.apply({"missing": options}, this);
+
+    		      if (options.length - are_missing.length >= need_count) {
+    		        return [];
+    		      } else {
+    		        return are_missing;
+    		      }
+    		    },
+    		  };
+
+    		  jsonLogic.is_logic = function(logic) {
+    		    return (
+    		      typeof logic === "object" && // An object
+    		      logic !== null && // but not null
+    		      ! Array.isArray(logic) && // and not an array
+    		      Object.keys(logic).length === 1 // with exactly one key
+    		    );
+    		  };
+
+    		  /*
+    		  This helper will defer to the JsonLogic spec as a tie-breaker when different language interpreters define different behavior for the truthiness of primitives.  E.g., PHP considers empty arrays to be falsy, but Javascript considers them to be truthy. JsonLogic, as an ecosystem, needs one consistent answer.
+
+    		  Spec and rationale here: http://jsonlogic.com/truthy
+    		  */
+    		  jsonLogic.truthy = function(value) {
+    		    if (Array.isArray(value) && value.length === 0) {
+    		      return false;
+    		    }
+    		    return !! value;
+    		  };
+
+
+    		  jsonLogic.get_operator = function(logic) {
+    		    return Object.keys(logic)[0];
+    		  };
+
+    		  jsonLogic.get_values = function(logic) {
+    		    return logic[jsonLogic.get_operator(logic)];
+    		  };
+
+    		  jsonLogic.apply = function(logic, data) {
+    		    // Does this array contain logic? Only one way to find out.
+    		    if (Array.isArray(logic)) {
+    		      return logic.map(function(l) {
+    		        return jsonLogic.apply(l, data);
+    		      });
+    		    }
+    		    // You've recursed to a primitive, stop!
+    		    if ( ! jsonLogic.is_logic(logic) ) {
+    		      return logic;
+    		    }
+
+    		    var op = jsonLogic.get_operator(logic);
+    		    var values = logic[op];
+    		    var i;
+    		    var current;
+    		    var scopedLogic;
+    		    var scopedData;
+    		    var initial;
+
+    		    // easy syntax for unary operators, like {"var" : "x"} instead of strict {"var" : ["x"]}
+    		    if ( ! Array.isArray(values)) {
+    		      values = [values];
+    		    }
+
+    		    // 'if', 'and', and 'or' violate the normal rule of depth-first calculating consequents, let each manage recursion as needed.
+    		    if (op === "if" || op == "?:") {
+    		      /* 'if' should be called with a odd number of parameters, 3 or greater
+    		      This works on the pattern:
+    		      if( 0 ){ 1 }else{ 2 };
+    		      if( 0 ){ 1 }else if( 2 ){ 3 }else{ 4 };
+    		      if( 0 ){ 1 }else if( 2 ){ 3 }else if( 4 ){ 5 }else{ 6 };
+
+    		      The implementation is:
+    		      For pairs of values (0,1 then 2,3 then 4,5 etc)
+    		      If the first evaluates truthy, evaluate and return the second
+    		      If the first evaluates falsy, jump to the next pair (e.g, 0,1 to 2,3)
+    		      given one parameter, evaluate and return it. (it's an Else and all the If/ElseIf were false)
+    		      given 0 parameters, return NULL (not great practice, but there was no Else)
+    		      */
+    		      for (i = 0; i < values.length - 1; i += 2) {
+    		        if ( jsonLogic.truthy( jsonLogic.apply(values[i], data) ) ) {
+    		          return jsonLogic.apply(values[i+1], data);
+    		        }
+    		      }
+    		      if (values.length === i+1) {
+    		        return jsonLogic.apply(values[i], data);
+    		      }
+    		      return null;
+    		    } else if (op === "and") { // Return first falsy, or last
+    		      for (i=0; i < values.length; i+=1) {
+    		        current = jsonLogic.apply(values[i], data);
+    		        if ( ! jsonLogic.truthy(current)) {
+    		          return current;
+    		        }
+    		      }
+    		      return current; // Last
+    		    } else if (op === "or") {// Return first truthy, or last
+    		      for (i=0; i < values.length; i+=1) {
+    		        current = jsonLogic.apply(values[i], data);
+    		        if ( jsonLogic.truthy(current) ) {
+    		          return current;
+    		        }
+    		      }
+    		      return current; // Last
+    		    } else if (op === "filter") {
+    		      scopedData = jsonLogic.apply(values[0], data);
+    		      scopedLogic = values[1];
+
+    		      if ( ! Array.isArray(scopedData)) {
+    		        return [];
+    		      }
+    		      // Return only the elements from the array in the first argument,
+    		      // that return truthy when passed to the logic in the second argument.
+    		      // For parity with JavaScript, reindex the returned array
+    		      return scopedData.filter(function(datum) {
+    		        return jsonLogic.truthy( jsonLogic.apply(scopedLogic, datum));
+    		      });
+    		    } else if (op === "map") {
+    		      scopedData = jsonLogic.apply(values[0], data);
+    		      scopedLogic = values[1];
+
+    		      if ( ! Array.isArray(scopedData)) {
+    		        return [];
+    		      }
+
+    		      return scopedData.map(function(datum) {
+    		        return jsonLogic.apply(scopedLogic, datum);
+    		      });
+    		    } else if (op === "reduce") {
+    		      scopedData = jsonLogic.apply(values[0], data);
+    		      scopedLogic = values[1];
+    		      initial = typeof values[2] !== "undefined" ? jsonLogic.apply(values[2], data) : null;
+
+    		      if ( ! Array.isArray(scopedData)) {
+    		        return initial;
+    		      }
+
+    		      return scopedData.reduce(
+    		        function(accumulator, current) {
+    		          return jsonLogic.apply(
+    		            scopedLogic,
+    		            {current: current, accumulator: accumulator}
+    		          );
+    		        },
+    		        initial
+    		      );
+    		    } else if (op === "all") {
+    		      scopedData = jsonLogic.apply(values[0], data);
+    		      scopedLogic = values[1];
+    		      // All of an empty set is false. Note, some and none have correct fallback after the for loop
+    		      if ( ! Array.isArray(scopedData) || ! scopedData.length) {
+    		        return false;
+    		      }
+    		      for (i=0; i < scopedData.length; i+=1) {
+    		        if ( ! jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {
+    		          return false; // First falsy, short circuit
+    		        }
+    		      }
+    		      return true; // All were truthy
+    		    } else if (op === "none") {
+    		      scopedData = jsonLogic.apply(values[0], data);
+    		      scopedLogic = values[1];
+
+    		      if ( ! Array.isArray(scopedData) || ! scopedData.length) {
+    		        return true;
+    		      }
+    		      for (i=0; i < scopedData.length; i+=1) {
+    		        if ( jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {
+    		          return false; // First truthy, short circuit
+    		        }
+    		      }
+    		      return true; // None were truthy
+    		    } else if (op === "some") {
+    		      scopedData = jsonLogic.apply(values[0], data);
+    		      scopedLogic = values[1];
+
+    		      if ( ! Array.isArray(scopedData) || ! scopedData.length) {
+    		        return false;
+    		      }
+    		      for (i=0; i < scopedData.length; i+=1) {
+    		        if ( jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {
+    		          return true; // First truthy, short circuit
+    		        }
+    		      }
+    		      return false; // None were truthy
+    		    }
+
+    		    // Everyone else gets immediate depth-first recursion
+    		    values = values.map(function(val) {
+    		      return jsonLogic.apply(val, data);
+    		    });
+
+
+    		    // The operation is called with "data" bound to its "this" and "values" passed as arguments.
+    		    // Structured commands like % or > can name formal arguments while flexible commands (like missing or merge) can operate on the pseudo-array arguments
+    		    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
+    		    if (operations.hasOwnProperty(op) && typeof operations[op] === "function") {
+    		      return operations[op].apply(data, values);
+    		    } else if (op.indexOf(".") > 0) { // Contains a dot, and not in the 0th position
+    		      var sub_ops = String(op).split(".");
+    		      var operation = operations;
+    		      for (i = 0; i < sub_ops.length; i++) {
+    		        if (!operation.hasOwnProperty(sub_ops[i])) {
+    		          throw new Error("Unrecognized operation " + op +
+    		            " (failed at " + sub_ops.slice(0, i+1).join(".") + ")");
+    		        }
+    		        // Descending into operations
+    		        operation = operation[sub_ops[i]];
+    		      }
+
+    		      return operation.apply(data, values);
+    		    }
+
+    		    throw new Error("Unrecognized operation " + op );
+    		  };
+
+    		  jsonLogic.uses_data = function(logic) {
+    		    var collection = [];
+
+    		    if (jsonLogic.is_logic(logic)) {
+    		      var op = jsonLogic.get_operator(logic);
+    		      var values = logic[op];
+
+    		      if ( ! Array.isArray(values)) {
+    		        values = [values];
+    		      }
+
+    		      if (op === "var") {
+    		        // This doesn't cover the case where the arg to var is itself a rule.
+    		        collection.push(values[0]);
+    		      } else {
+    		        // Recursion!
+    		        values.forEach(function(val) {
+    		          collection.push.apply(collection, jsonLogic.uses_data(val) );
+    		        });
+    		      }
+    		    }
+
+    		    return arrayUnique(collection);
+    		  };
+
+    		  jsonLogic.add_operation = function(name, code) {
+    		    operations[name] = code;
+    		  };
+
+    		  jsonLogic.rm_operation = function(name) {
+    		    delete operations[name];
+    		  };
+
+    		  jsonLogic.rule_like = function(rule, pattern) {
+    		    // console.log("Is ". JSON.stringify(rule) . " like " . JSON.stringify(pattern) . "?");
+    		    if (pattern === rule) {
+    		      return true;
+    		    } // TODO : Deep object equivalency?
+    		    if (pattern === "@") {
+    		      return true;
+    		    } // Wildcard!
+    		    if (pattern === "number") {
+    		      return (typeof rule === "number");
+    		    }
+    		    if (pattern === "string") {
+    		      return (typeof rule === "string");
+    		    }
+    		    if (pattern === "array") {
+    		      // !logic test might be superfluous in JavaScript
+    		      return Array.isArray(rule) && ! jsonLogic.is_logic(rule);
+    		    }
+
+    		    if (jsonLogic.is_logic(pattern)) {
+    		      if (jsonLogic.is_logic(rule)) {
+    		        var pattern_op = jsonLogic.get_operator(pattern);
+    		        var rule_op = jsonLogic.get_operator(rule);
+
+    		        if (pattern_op === "@" || pattern_op === rule_op) {
+    		          // echo "\nOperators match, go deeper\n";
+    		          return jsonLogic.rule_like(
+    		            jsonLogic.get_values(rule, false),
+    		            jsonLogic.get_values(pattern, false)
+    		          );
+    		        }
+    		      }
+    		      return false; // pattern is logic, rule isn't, can't be eq
+    		    }
+
+    		    if (Array.isArray(pattern)) {
+    		      if (Array.isArray(rule)) {
+    		        if (pattern.length !== rule.length) {
+    		          return false;
+    		        }
+    		        /*
+    		          Note, array order MATTERS, because we're using this array test logic to consider arguments, where order can matter. (e.g., + is commutative, but '-' or 'if' or 'var' are NOT)
+    		        */
+    		        for (var i = 0; i < pattern.length; i += 1) {
+    		          // If any fail, we fail
+    		          if ( ! jsonLogic.rule_like(rule[i], pattern[i])) {
+    		            return false;
+    		          }
+    		        }
+    		        return true; // If they *all* passed, we pass
+    		      } else {
+    		        return false; // Pattern is array, rule isn't
+    		      }
+    		    }
+
+    		    // Not logic, not array, not a === match for rule.
+    		    return false;
+    		  };
+
+    		  return jsonLogic;
+    		})); 
+    	} (logic$1));
+    	return logic$1.exports;
+    }
+
+    var logicExports = requireLogic();
+    var jsonLogic = /*@__PURE__*/getDefaultExportFromCjs(logicExports);
+
+    /**
+     * Check if an event matches the given criteria
+     * @param {string} eventName - The name of the event being checked
+     * @param {Object} properties - Event properties to evaluate against property filters
+     * @param {Object} criteria - Criteria to match against, with:
+     *   - event_name: string - Required event name (case-sensitive match)
+     *   - property_filters: Object - Optional JsonLogic filters for properties
+     * @returns {Object} Result object with:
+     *   - matches: boolean - Whether the event matches the criteria
+     *   - error: string|undefined - Error message if evaluation failed
+     */
+    var eventMatchesCriteria = function(eventName, properties, criteria) {
+        // Check exact event name match (case-sensitive)
+        if (eventName !== criteria.event_name) {
+            return { matches: false };
+        }
+
+        // Evaluate property filters using JsonLogic
+        var propertyFilters = criteria.property_filters;
+        var filtersMatch = true; // default to true if no filters
+
+        if (propertyFilters && !_.isEmptyObject(propertyFilters)) {
+            try {
+                // Use properties as-is for case-sensitive matching
+                filtersMatch = jsonLogic.apply(propertyFilters, properties || {});
+            } catch (error) {
+                return {
+                    matches: false,
+                    error: error.toString()
+                };
+            }
+        }
+
+        return { matches: filtersMatch };
+    };
+
+    // Create targeting library object
+    var targetingLibrary = {};
+    targetingLibrary['eventMatchesCriteria'] = eventMatchesCriteria;
+
+    // Set global Promise (use bracket notation to prevent minification)
+    // This is the ONE AND ONLY global - matches recorder pattern
+    win[TARGETING_GLOBAL_NAME] = Promise.resolve(targetingLibrary);
 
     /** @const */ var DEFAULT_RAGE_CLICK_THRESHOLD_PX = 30;
     /** @const */ var DEFAULT_RAGE_CLICK_TIMEOUT_MS = 1000;
@@ -23867,7 +25193,7 @@
             observer.observe(shadowRoot, this.observerConfig);
             this.shadowObservers.push(observer);
         } catch (e) {
-            logger$3.critical('Error while observing shadow root', e);
+            logger$4.critical('Error while observing shadow root', e);
         }
     };
 
@@ -23878,7 +25204,7 @@
         }
 
         if (!weakSetSupported()) {
-            logger$3.critical('Shadow DOM observation unavailable: WeakSet not supported');
+            logger$4.critical('Shadow DOM observation unavailable: WeakSet not supported');
             return;
         }
 
@@ -23894,7 +25220,7 @@
             try {
                 this.shadowObservers[i].disconnect();
             } catch (e) {
-                logger$3.critical('Error while disconnecting shadow DOM observer', e);
+                logger$4.critical('Error while disconnecting shadow DOM observer', e);
             }
         }
         this.shadowObservers = [];
@@ -24082,7 +25408,7 @@
 
                 this.mutationObserver.observe(document.body || document.documentElement, MUTATION_OBSERVER_CONFIG);
             } catch (e) {
-                logger$3.critical('Error while setting up mutation observer', e);
+                logger$4.critical('Error while setting up mutation observer', e);
             }
         }
 
@@ -24097,7 +25423,7 @@
                 );
                 this.shadowDOMObserver.start();
             } catch (e) {
-                logger$3.critical('Error while setting up shadow DOM observer', e);
+                logger$4.critical('Error while setting up shadow DOM observer', e);
                 this.shadowDOMObserver = null;
             }
         }
@@ -24124,7 +25450,7 @@
             try {
                 listener.target.removeEventListener(listener.event, listener.handler, listener.options);
             } catch (e) {
-                logger$3.critical('Error while removing event listener', e);
+                logger$4.critical('Error while removing event listener', e);
             }
         }
         this.eventListeners = [];
@@ -24133,7 +25459,7 @@
             try {
                 this.mutationObserver.disconnect();
             } catch (e) {
-                logger$3.critical('Error while disconnecting mutation observer', e);
+                logger$4.critical('Error while disconnecting mutation observer', e);
             }
             this.mutationObserver = null;
         }
@@ -24142,7 +25468,7 @@
             try {
                 this.shadowDOMObserver.stop();
             } catch (e) {
-                logger$3.critical('Error while stopping shadow DOM observer', e);
+                logger$4.critical('Error while stopping shadow DOM observer', e);
             }
             this.shadowDOMObserver = null;
         }
@@ -24220,7 +25546,7 @@
 
     Autocapture.prototype.init = function() {
         if (!minDOMApisSupported()) {
-            logger$3.critical('Autocapture unavailable: missing required DOM APIs');
+            logger$4.critical('Autocapture unavailable: missing required DOM APIs');
             return;
         }
         this.initPageListeners();
@@ -24252,27 +25578,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$4.critical('Error while checking block URL regexes: ', err);
                 return true;
             }
         }
@@ -24282,17 +25596,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$4.critical('Error while checking block URL regexes: ', err);
+            return true;
         }
-        return false;
     };
 
     Autocapture.prototype.pageviewTrackingConfig = function() {
@@ -24428,7 +25737,7 @@
             return;
         }
 
-        logger$3.log('Initializing scroll depth tracking');
+        logger$4.log('Initializing scroll depth tracking');
 
         this.maxScrollViewDepth = Math.max(document$1.documentElement.clientHeight, win.innerHeight || 0);
 
@@ -24454,7 +25763,7 @@
         if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.get_config('record_heatmap_data')) {
             return;
         }
-        logger$3.log('Initializing click tracking');
+        logger$4.log('Initializing click tracking');
 
         this.listenerClick = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.is_recording_heatmap_data()) {
@@ -24473,7 +25782,7 @@
             return;
         }
 
-        logger$3.log('Initializing dead click tracking');
+        logger$4.log('Initializing dead click tracking');
         if (!this._deadClickTracker) {
             this._deadClickTracker = new DeadClickTracker(function(deadClickEvent) {
                 this.trackDomEvent(deadClickEvent, MP_EV_DEAD_CLICK);
@@ -24507,7 +25816,7 @@
         if (!this.getConfig(CONFIG_TRACK_INPUT)) {
             return;
         }
-        logger$3.log('Initializing input tracking');
+        logger$4.log('Initializing input tracking');
 
         this.listenerChange = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_INPUT)) {
@@ -24524,7 +25833,7 @@
         if (!this.pageviewTrackingConfig()) {
             return;
         }
-        logger$3.log('Initializing pageview tracking');
+        logger$4.log('Initializing pageview tracking');
 
         var previousTrackedUrl = '';
         var tracked = false;
@@ -24559,7 +25868,7 @@
                 }
                 if (didPathChange) {
                     this.lastScrollCheckpoint = 0;
-                    logger$3.log('Path change: re-initializing scroll depth checkpoints');
+                    logger$4.log('Path change: re-initializing scroll depth checkpoints');
                 }
             }
         }.bind(this));
@@ -24574,7 +25883,7 @@
             return;
         }
 
-        logger$3.log('Initializing rage click tracking');
+        logger$4.log('Initializing rage click tracking');
         if (!this._rageClickTracker) {
             this._rageClickTracker = new RageClickTracker();
         }
@@ -24604,7 +25913,7 @@
         if (!this.getConfig(CONFIG_TRACK_SCROLL)) {
             return;
         }
-        logger$3.log('Initializing scroll tracking');
+        logger$4.log('Initializing scroll tracking');
         this.lastScrollCheckpoint = 0;
 
         var scrollTrackFunction = function() {
@@ -24641,7 +25950,7 @@
                     }
                 }
             } catch (err) {
-                logger$3.critical('Error while calculating scroll percentage', err);
+                logger$4.critical('Error while calculating scroll percentage', err);
             }
             if (shouldTrack) {
                 this.mp.track(MP_EV_SCROLL, props);
@@ -24659,7 +25968,7 @@
         if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
             return;
         }
-        logger$3.log('Initializing submit tracking');
+        logger$4.log('Initializing submit tracking');
 
         this.listenerSubmit = function(ev) {
             if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
@@ -24681,7 +25990,7 @@
             return;
         }
 
-        logger$3.log('Initializing page visibility tracking.');
+        logger$4.log('Initializing page visibility tracking.');
         this._initScrollDepthTracking();
         var previousTrackedUrl = _.info.currentUrl();
 
@@ -24736,14 +26045,62 @@
     // TODO integrate error_reporter from mixpanel instance
     safewrapClass(Autocapture);
 
-    var logger = console_with_prefix('flags');
+    /**
+     * Get the promise-based targeting loader
+     * @param {Function} loadExtraBundle - Function to load external bundle (callback-based)
+     * @param {string} targetingSrc - URL to targeting bundle
+     * @returns {Promise} Promise that resolves with targeting library
+     */
+    var getTargetingPromise = function(loadExtraBundle, targetingSrc) {
+        // Return existing promise if already initialized or loading
+        if (win[TARGETING_GLOBAL_NAME] && typeof win[TARGETING_GLOBAL_NAME].then === 'function') {
+            return win[TARGETING_GLOBAL_NAME];
+        }
+
+        // Create loading promise and set it as the global immediately
+        // This makes minified build behavior consistent with dev/CJS builds
+        win[TARGETING_GLOBAL_NAME] = new Promise(function (resolve) {
+            loadExtraBundle(targetingSrc, resolve);
+        }).then(function () {
+            var p = win[TARGETING_GLOBAL_NAME];
+            if (p && typeof p.then === 'function') {
+                return p;
+            }
+            throw new Error('targeting failed to load');
+        }).catch(function (err) {
+            delete win[TARGETING_GLOBAL_NAME];
+            throw err;
+        });
 
+        return win[TARGETING_GLOBAL_NAME];
+    };
+
+    var logger = console_with_prefix('flags');
     var FLAGS_CONFIG_KEY = 'flags';
 
     var CONFIG_CONTEXT = 'context';
     var CONFIG_DEFAULTS = {};
     CONFIG_DEFAULTS[CONFIG_CONTEXT] = {};
 
+    /**
+     * Generate a unique key for a pending first-time event
+     * @param {string} flagKey - The flag key
+     * @param {string} firstTimeEventHash - The first_time_event_hash from the pending event definition
+     * @returns {string} Composite key in format "flagKey:firstTimeEventHash"
+     */
+    var getPendingEventKey = function(flagKey, firstTimeEventHash) {
+        return flagKey + ':' + firstTimeEventHash;
+    };
+
+    /**
+     * Extract the flag key from a pending event key
+     * @param {string} eventKey - The composite event key in format "flagKey:firstTimeEventHash"
+     * @returns {string} The flag key portion
+     */
+    var getFlagKeyFromPendingEventKey = function(eventKey) {
+        return eventKey.split(':')[0];
+    };
+
     /**
      * FeatureFlagManager: support for Mixpanel's feature flagging product
      * @constructor
@@ -24755,6 +26112,8 @@
         this.setMpConfig = initOptions.setConfigFunc;
         this.getMpProperty = initOptions.getPropertyFunc;
         this.track = initOptions.trackingFunc;
+        this.loadExtraBundle = initOptions.loadExtraBundle || function() {};
+        this.targetingSrc = initOptions.targetingSrc || '';
     };
 
     FeatureFlagManager.prototype.init = function() {
@@ -24767,6 +26126,8 @@
         this.fetchFlags();
 
         this.trackedFeatures = new Set();
+        this.pendingFirstTimeEvents = {};
+        this.activatedFirstTimeEvents = {};
     };
 
     FeatureFlagManager.prototype.getFullConfig = function() {
@@ -24847,17 +26208,78 @@
                     throw new Error('No flags in API response');
                 }
                 var flags = new Map();
+                var pendingFirstTimeEvents = {};
+
+                // Process flags from response
                 _.each(responseFlags, function(data, key) {
-                    flags.set(key, {
-                        'key': data['variant_key'],
-                        'value': data['variant_value'],
-                        'experiment_id': data['experiment_id'],
-                        'is_experiment_active': data['is_experiment_active'],
-                        'is_qa_tester': data['is_qa_tester']
+                    // Check if this flag has any activated first-time events this session
+                    var hasActivatedEvent = false;
+                    var prefix = key + ':';
+                    _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
+                        if (eventKey.startsWith(prefix)) {
+                            hasActivatedEvent = true;
+                        }
                     });
-                });
+
+                    if (hasActivatedEvent) {
+                        // Preserve the activated variant, don't overwrite with server's current variant
+                        var currentFlag = this.flags && this.flags.get(key);
+                        if (currentFlag) {
+                            flags.set(key, currentFlag);
+                        }
+                    } else {
+                        // Use server's current variant
+                        flags.set(key, {
+                            'key': data['variant_key'],
+                            'value': data['variant_value'],
+                            'experiment_id': data['experiment_id'],
+                            'is_experiment_active': data['is_experiment_active'],
+                            'is_qa_tester': data['is_qa_tester']
+                        });
+                    }
+                }, this);
+
+                // Process top-level pending_first_time_events array
+                var topLevelDefinitions = responseBody['pending_first_time_events'];
+                if (topLevelDefinitions && topLevelDefinitions.length > 0) {
+                    _.each(topLevelDefinitions, function(def) {
+                        var flagKey = def['flag_key'];
+                        var eventKey = getPendingEventKey(flagKey, def['first_time_event_hash']);
+
+                        // Skip if this specific event has already been activated this session
+                        if (this.activatedFirstTimeEvents[eventKey]) {
+                            return;
+                        }
+
+                        // Store pending event definition using composite key
+                        pendingFirstTimeEvents[eventKey] = {
+                            'flag_key': flagKey,
+                            'flag_id': def['flag_id'],
+                            'project_id': def['project_id'],
+                            'first_time_event_hash': def['first_time_event_hash'],
+                            'event_name': def['event_name'],
+                            'property_filters': def['property_filters'],
+                            'pending_variant': def['pending_variant']
+                        };
+                    }, this);
+                }
+
+                // Preserve any activated orphaned flags (flags that were activated but are no longer in response)
+                if (this.activatedFirstTimeEvents) {
+                    _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
+                        var flagKey = getFlagKeyFromPendingEventKey(eventKey);
+                        if (activated && !flags.has(flagKey) && this.flags && this.flags.has(flagKey)) {
+                            // Keep the activated flag even though it's not in the new response
+                            flags.set(flagKey, this.flags.get(flagKey));
+                        }
+                    }, this);
+                }
+
                 this.flags = flags;
+                this.pendingFirstTimeEvents = pendingFirstTimeEvents;
                 this._traceparent = traceparent;
+
+                this._loadTargetingIfNeeded();
             }.bind(this)).catch(function(error) {
                 this.markFetchComplete();
                 logger.error(error);
@@ -24870,15 +26292,186 @@
         return this.fetchPromise;
     };
 
-    FeatureFlagManager.prototype.markFetchComplete = function() {
-        if (!this._fetchInProgressStartTime) {
-            logger.error('Fetch in progress started time not set, cannot mark fetch complete');
-            return;
-        }
-        this._fetchStartTime = this._fetchInProgressStartTime;
-        this._fetchCompleteTime = Date.now();
-        this._fetchLatency = this._fetchCompleteTime - this._fetchStartTime;
-        this._fetchInProgressStartTime = null;
+    FeatureFlagManager.prototype.markFetchComplete = function() {
+        if (!this._fetchInProgressStartTime) {
+            logger.error('Fetch in progress started time not set, cannot mark fetch complete');
+            return;
+        }
+        this._fetchStartTime = this._fetchInProgressStartTime;
+        this._fetchCompleteTime = Date.now();
+        this._fetchLatency = this._fetchCompleteTime - this._fetchStartTime;
+        this._fetchInProgressStartTime = null;
+    };
+
+    /**
+     * Proactively load targeting bundle if any pending events have property filters
+     */
+    FeatureFlagManager.prototype._loadTargetingIfNeeded = function() {
+        var hasPropertyFilters = false;
+        _.each(this.pendingFirstTimeEvents, function(evt) {
+            if (evt['property_filters'] && !_.isEmptyObject(evt['property_filters'])) {
+                hasPropertyFilters = true;
+            }
+        });
+
+        if (hasPropertyFilters) {
+            this.getTargeting().then(function() {
+                logger.log('targeting loaded for property filter evaluation');
+            });
+        }
+    };
+
+    /**
+     * Get the targeting library (initializes if not already loaded)
+     * This method is primarily for testing - production code should rely on automatic loading
+     * @returns {Promise} Promise that resolves with targeting library
+     */
+    FeatureFlagManager.prototype.getTargeting = function() {
+        return getTargetingPromise(
+            this.loadExtraBundle.bind(this),
+            this.targetingSrc
+        ).catch(function(error) {
+            logger.error('Failed to load targeting: ' + error);
+        }.bind(this));
+    };
+
+    /**
+     * Check if a tracked event matches any pending first-time events and activate the corresponding flag variant
+     * @param {string} eventName - The name of the event being tracked
+     * @param {Object} properties - Event properties to evaluate against property filters
+     *
+     * When a match is found (event name matches and property filters pass), this method:
+     * - Switches the flag to the pending variant
+     * - Marks the event as activated for this session
+     * - Records the activation via the API (fire-and-forget)
+     */
+    FeatureFlagManager.prototype.checkFirstTimeEvents = function(eventName, properties) {
+        if (!this.pendingFirstTimeEvents || _.isEmptyObject(this.pendingFirstTimeEvents)) {
+            return;
+        }
+
+        // Check if targeting promise exists (either bundled or async loaded)
+        if (win[TARGETING_GLOBAL_NAME] && _.isFunction(win[TARGETING_GLOBAL_NAME].then)) {
+            win[TARGETING_GLOBAL_NAME].then(function(library) {
+                this._processFirstTimeEventCheck(eventName, properties, library);
+            }.bind(this)).catch(function() {
+                // If targeting failed to load, process with null
+                // Events without property filters will still match
+                this._processFirstTimeEventCheck(eventName, properties, null);
+            }.bind(this));
+        } else {
+            // No targeting available, process with null
+            // Events without property filters will still match
+            this._processFirstTimeEventCheck(eventName, properties, null);
+        }
+    };
+
+    /**
+     * Internal method to process first-time event checks with loaded targeting library
+     * @param {string} eventName - The name of the event being tracked
+     * @param {Object} properties - Event properties to evaluate against property filters
+     * @param {Object} targeting - The loaded targeting library
+     */
+    FeatureFlagManager.prototype._processFirstTimeEventCheck = function(eventName, properties, targeting) {
+        _.each(this.pendingFirstTimeEvents, function(pendingEvent, eventKey) {
+            if (this.activatedFirstTimeEvents[eventKey]) {
+                return;
+            }
+
+            var flagKey = pendingEvent['flag_key'];
+
+            // Use targeting module to check if event matches
+            var matchResult;
+
+            // 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');
+                return;
+            }
+
+            // For simple events (no property filters), just check event name
+            if (!targeting) {
+                matchResult = {
+                    matches: eventName === pendingEvent['event_name'],
+                    error: null
+                };
+            } else {
+                var criteria = {
+                    'event_name': pendingEvent['event_name'],
+                    'property_filters': pendingEvent['property_filters']
+                };
+                matchResult = targeting['eventMatchesCriteria'](
+                    eventName,
+                    properties,
+                    criteria
+                );
+            }
+
+            if (matchResult.error) {
+                logger.error('Error checking first-time event for flag "' + flagKey + '": ' + matchResult.error);
+                return;
+            }
+
+            if (!matchResult.matches) {
+                return;
+            }
+
+            logger.log('First-time event matched for flag "' + flagKey + '": ' + eventName);
+
+            var newVariant = {
+                'key': pendingEvent['pending_variant']['variant_key'],
+                'value': pendingEvent['pending_variant']['variant_value'],
+                'experiment_id': pendingEvent['pending_variant']['experiment_id'],
+                'is_experiment_active': pendingEvent['pending_variant']['is_experiment_active']
+            };
+
+            this.flags.set(flagKey, newVariant);
+            this.activatedFirstTimeEvents[eventKey] = true;
+
+            this.recordFirstTimeEvent(
+                pendingEvent['flag_id'],
+                pendingEvent['project_id'],
+                pendingEvent['first_time_event_hash']
+            );
+        }, this);
+    };
+
+    FeatureFlagManager.prototype.getFirstTimeEventApiRoute = function(flagId) {
+        // Construct URL: {api_host}/flags/{flagId}/first-time-events
+        return this.getFullApiRoute() + '/' + flagId + '/first-time-events';
+    };
+
+    FeatureFlagManager.prototype.recordFirstTimeEvent = function(flagId, projectId, firstTimeEventHash) {
+        var distinctId = this.getMpProperty('distinct_id');
+        var traceparent = generateTraceparent();
+
+        // Build URL with query string parameters
+        var searchParams = new URLSearchParams();
+        searchParams.set('mp_lib', 'web');
+        searchParams.set('$lib_version', Config.LIB_VERSION);
+        var url = this.getFirstTimeEventApiRoute(flagId) + '?' + searchParams.toString();
+
+        var payload = {
+            'distinct_id': distinctId,
+            'project_id': projectId,
+            'first_time_event_hash': firstTimeEventHash
+        };
+
+        logger.log('Recording first-time event for flag: ' + flagId);
+
+        // Fire-and-forget POST request
+        this.fetch.call(win, url, {
+            'method': 'POST',
+            'headers': {
+                'Content-Type': 'application/json',
+                'Authorization': 'Basic ' + btoa(this.getMpConfig('token') + ':'),
+                'traceparent': traceparent
+            },
+            '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);
+        });
     };
 
     FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
@@ -24999,6 +26592,217 @@
     // Deprecated method
     FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
 
+    // Exports intended only for testing
+    FeatureFlagManager.prototype['getTargeting'] = FeatureFlagManager.prototype.getTargeting;
+
+    /* eslint camelcase: "off" */
+
+
+    /**
+     * 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;
+    };
+
+    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);
+
+        /**
+         * 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;
+        }
+    };
+
+    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);
+                }
+            }
+        }
+    };
+
+    RecorderManager.prototype.stopSessionRecording = function() {
+        if (this._recorder) {
+            return this._recorder['stopRecording']();
+        }
+        return PromisePolyfill.resolve();
+    };
+
+    RecorderManager.prototype.pauseSessionRecording = function() {
+        if (this._recorder) {
+            return this._recorder['pauseRecording']();
+        }
+        return PromisePolyfill.resolve();
+    };
+
+    RecorderManager.prototype.resumeSessionRecording = function() {
+        if (this._recorder) {
+            return this._recorder['resumeRecording']();
+        }
+        return PromisePolyfill.resolve();
+    };
+
+    RecorderManager.prototype.isRecordingHeatmapData = function() {
+        return this.getSessionReplayId() && this.getMpConfig('record_heatmap_data');
+    };
+
+    RecorderManager.prototype.getSessionRecordingProperties = function() {
+        var props = {};
+        var replay_id = this.getSessionReplayId();
+        if (replay_id) {
+            props['$mp_replay_id'] = replay_id;
+        }
+        return props;
+    };
+
+    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;
+    };
+
+    RecorderManager.prototype.getSessionReplayId = function() {
+        var replay_id = null;
+        if (this._recorder) {
+            replay_id = this._recorder['replayId'];
+        }
+        return replay_id || null;
+    };
+
+    // "private" public method to reach into the recorder in test cases
+    RecorderManager.prototype.getRecorder = function() {
+        return this._recorder;
+    };
+
+    safewrapClass(RecorderManager);
+
     /* eslint camelcase: "off" */
 
 
@@ -26462,12 +28266,17 @@
         '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',
+        'recorder_src':                      null,
+        'targeting_src':                     null,
+        'lib_base_path':                     'https://cdn.mxpnl.com/libs/',
         'remote_settings_mode':              SETTING_DISABLED // 'strict', 'fallback', 'disabled'
     };
 
@@ -26621,6 +28430,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 = [];
@@ -26697,7 +28519,9 @@
             getConfigFunc: _.bind(this.get_config, this),
             setConfigFunc: _.bind(this.set_config, this),
             getPropertyFunc: _.bind(this.get_property, this),
-            trackingFunc: _.bind(this.track, this)
+            trackingFunc: _.bind(this.track, this),
+            loadExtraBundle: load_extra_bundle,
+            targetingSrc: this.get_config('targeting_src') || (this.get_config('lib_base_path') + TARGETING_FILENAME)
         });
         this.flags.init();
         this['flags'] = this.flags;
@@ -26710,11 +28534,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();
         }
     };
 
@@ -26758,132 +28582,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['__mp_recorder'](this);
-                this._recorder['resumeRecording'](startNewIfInactive);
-            }, this);
-
-            if (_.isUndefined(win['__mp_recorder'])) {
-                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
@@ -27141,6 +28883,7 @@
     };
 
     MixpanelLib.prototype._fetch_remote_settings = function(mode) {
+        var self = this;
         var disableRecordingIfStrict = function() {
             if (mode === 'strict') {
                 self.set_config({'record_sessions_percent': 0});
@@ -27161,7 +28904,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() {
@@ -27353,6 +29095,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
@@ -27526,6 +29296,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
@@ -27539,6 +29311,11 @@
             send_request_options: options
         }, callback);
 
+        // Check for first-time event matches
+        if (this.flags && this.flags.checkFirstTimeEvents) {
+            this.flags.checkFirstTimeEvents(event_name, properties);
+        }
+
         return ret;
     });
 
@@ -28729,6 +30506,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;
@@ -28772,6 +30550,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;