mixpanel-browser 2.74.0 → 2.76.0

package/dist/mixpanel-with-recorder.js

@@ -26,6 +26,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];
@@ -640,14 +653,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);
                 });
             }
         };
@@ -10389,6 +10404,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) {
@@ -10711,7 +10735,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;
@@ -11085,6 +11117,9 @@
             this.shadowDomManager.reset();
             this.canvasManager.reset();
         };
+        _proto.getDoc = function getDoc() {
+            return this.doc;
+        };
         return MutationBuffer;
     }();
     function deepDelete(addsSet, n2) {
@@ -11185,6 +11220,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) {
@@ -12200,6 +12243,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");
@@ -12221,6 +12266,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;
         };
@@ -12239,6 +12309,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));
@@ -13151,6 +13224,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;
@@ -13605,7 +13713,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);
                 }
@@ -18014,7 +18138,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() {};
@@ -18431,7 +18555,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++){
@@ -18852,11 +18976,6 @@
         PromisePolyfill = NpoPromise;
     }
 
-    var Config = {
-        DEBUG: false,
-        LIB_VERSION: '2.74.0'
-    };
-
     /* eslint camelcase: "off", eqeqeq: "off" */
 
     // Maximum allowed session recording length
@@ -19060,15 +19179,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) {
@@ -20595,6 +20707,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;
@@ -21066,7 +21189,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
@@ -21118,7 +21241,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();
@@ -21265,7 +21388,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.
@@ -21294,7 +21417,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
 
@@ -21627,7 +21750,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
@@ -21755,7 +21878,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();
         }
 
@@ -21932,7 +22055,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) {
@@ -21945,7 +22068,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)) {
@@ -21953,7 +22076,7 @@
                 }
                 this.errorReporter(msg, err);
             } catch(err) {
-                logger$4.error(err);
+                logger$5.error(err);
             }
         }
     };
@@ -22075,7 +22198,7 @@
 
     var MAX_DEPTH = 5;
 
-    var logger$3 = console_with_prefix('autocapture');
+    var logger$4 = console_with_prefix('autocapture');
 
 
     function getClasses(el) {
@@ -22339,7 +22462,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;
             }
         }
@@ -22356,7 +22479,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;
@@ -22371,7 +22494,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;
             }
         }
@@ -22385,7 +22508,7 @@
                         return true;
                     }
                 } catch (err) {
-                    logger$3.critical('Error while checking selector: ' + sel, err);
+                    logger$4.critical('Error while checking selector: ' + sel, err);
                 }
             }
         }
@@ -22933,173 +23056,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);
     };
 
@@ -23165,6 +23937,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) {
@@ -23203,15 +23998,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);
@@ -23326,6 +24113,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.
@@ -23345,7 +24136,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') + ':'),
@@ -23746,8 +24537,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;
@@ -23762,7 +24557,7 @@
         }
     });
 
-    win['__mp_recorder'] = MixpanelRecorder;
+    win[RECORDER_GLOBAL_NAME] = MixpanelRecorder;
 
     /** @const */ var DEFAULT_RAGE_CLICK_THRESHOLD_PX = 30;
     /** @const */ var DEFAULT_RAGE_CLICK_TIMEOUT_MS = 1000;
@@ -23864,7 +24659,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);
         }
     };
 
@@ -23875,7 +24670,7 @@
         }
 
         if (!weakSetSupported()) {
-            logger$3.critical('Shadow DOM observation unavailable: WeakSet not supported');
+            logger$4.critical('Shadow DOM observation unavailable: WeakSet not supported');
             return;
         }
 
@@ -23891,7 +24686,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 = [];
@@ -24079,7 +24874,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);
             }
         }
 
@@ -24094,7 +24889,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;
             }
         }
@@ -24121,7 +24916,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 = [];
@@ -24130,7 +24925,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;
         }
@@ -24139,7 +24934,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;
         }
@@ -24217,7 +25012,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();
@@ -24249,27 +25044,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;
             }
         }
@@ -24279,17 +25062,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() {
@@ -24425,7 +25203,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);
 
@@ -24451,7 +25229,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()) {
@@ -24470,7 +25248,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);
@@ -24504,7 +25282,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)) {
@@ -24521,7 +25299,7 @@
         if (!this.pageviewTrackingConfig()) {
             return;
         }
-        logger$3.log('Initializing pageview tracking');
+        logger$4.log('Initializing pageview tracking');
 
         var previousTrackedUrl = '';
         var tracked = false;
@@ -24556,7 +25334,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));
@@ -24571,7 +25349,7 @@
             return;
         }
 
-        logger$3.log('Initializing rage click tracking');
+        logger$4.log('Initializing rage click tracking');
         if (!this._rageClickTracker) {
             this._rageClickTracker = new RageClickTracker();
         }
@@ -24601,7 +25379,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() {
@@ -24638,7 +25416,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);
@@ -24656,7 +25434,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)) {
@@ -24678,7 +25456,7 @@
             return;
         }
 
-        logger$3.log('Initializing page visibility tracking.');
+        logger$4.log('Initializing page visibility tracking.');
         this._initScrollDepthTracking();
         var previousTrackedUrl = _.info.currentUrl();
 
@@ -24733,14 +25511,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
@@ -24752,6 +25578,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() {
@@ -24764,6 +25592,8 @@
         this.fetchFlags();
 
         this.trackedFeatures = new Set();
+        this.pendingFirstTimeEvents = {};
+        this.activatedFirstTimeEvents = {};
     };
 
     FeatureFlagManager.prototype.getFullConfig = function() {
@@ -24844,17 +25674,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);
@@ -24867,15 +25758,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) {
@@ -24996,6 +26058,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" */
 
 
@@ -26459,12 +27732,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'
     };
 
@@ -26618,6 +27896,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 = [];
@@ -26694,7 +27985,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;
@@ -26707,11 +28000,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();
         }
     };
 
@@ -26755,132 +28048,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
@@ -27138,6 +28349,7 @@
     };
 
     MixpanelLib.prototype._fetch_remote_settings = function(mode) {
+        var self = this;
         var disableRecordingIfStrict = function() {
             if (mode === 'strict') {
                 self.set_config({'record_sessions_percent': 0});
@@ -27158,7 +28370,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() {
@@ -27350,6 +28561,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
@@ -27523,6 +28762,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
@@ -27536,6 +28777,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;
     });
 
@@ -28726,6 +29972,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;
@@ -28769,6 +30016,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;