@checksum-ai/runtime 1.1.50-beta → 1.1.52

package/checksumlib.js

@@ -7598,9 +7598,9 @@
         case Node.TEXT_NODE:
           return node2.nodeValue;
         case Node.CDATA_SECTION_NODE:
-          return includeCDATA ? `<![CDATA[${node2.nodeValue}]]>` : "";
+          return includeCDATA && node2.nodeValue.trim().length > 0 ? `<![CDATA[${node2.nodeValue}]]>` : "";
         case Node.COMMENT_NODE:
-          return includeComments ? `<!--${node2.nodeValue}-->` : "";
+          return includeComments && node2.nodeValue.trim().length > 0 ? `<!--${node2.nodeValue}-->` : "";
         default:
           return "";
       }
@@ -29412,52 +29412,14 @@
 
   // ../browser-lib/src/session-record-replay/session-replayer.ts
   var import_await_sleep3 = __toESM(require_await_sleep());
+  var DEBUG_MODE = false;
   var SessionReplayer = class {
     constructor(config = {}) {
-      this.events = [];
-      this.numberOfCastedEvents = 0;
-      this.isLive = true;
-      this.liveEvents = [];
-      // private currentTraveledTimestamp: number = undefined;
-      this.currentTraveledNumberOfEvents = void 0;
+      // array of events to init replayer
+      this.eventsBuffer = [];
       this.config = {
         enableInteract: false
       };
-      this.useTimestampCompression = true;
-      // getCurrentTraveledTimestamp = () => {
-      //   return this.isLive ? undefined : this.currentTraveledTimestamp;
-      // };
-      this.fastForward = /* @__PURE__ */ __name(async (newEvents, force = false) => {
-        let sortedNewEvents = newEvents.sort(
-          (e1, e2) => this.getOriginalTimestamp(e1) - this.getOriginalTimestamp(e2)
-        );
-        if (this.useTimestampCompression) {
-          const timestamp = Date.now();
-          sortedNewEvents = sortedNewEvents.map((event, eventIndex) => ({
-            ...event,
-            timestamp: timestamp + eventIndex,
-            originalTimestamp: this.getOriginalTimestamp(event)
-          }));
-        }
-        if (!force && !this.isLive) {
-          this.liveEvents.push(...sortedNewEvents);
-          return;
-        }
-        this.events = [...this.events, ...sortedNewEvents];
-        const promise = new Promise((resolve2) => {
-          this.onEventCast = (event) => {
-            this.numberOfCastedEvents++;
-            if (this.numberOfCastedEvents === this.events.length) {
-              this.onEventCast = void 0;
-              resolve2();
-            }
-          };
-        });
-        for (const event of sortedNewEvents) {
-          this.replayer.addEvent(event);
-        }
-        return promise;
-      }, "fastForward");
       this.stop = /* @__PURE__ */ __name(() => {
         try {
           if (this.replayer) {
@@ -29467,234 +29429,146 @@
           console.warn("Error destroying replayer", e2);
         }
       }, "stop");
-      this.getOriginalTimestamp = /* @__PURE__ */ __name((event) => {
-        return event.originalTimestamp ?? event.timestamp;
-      }, "getOriginalTimestamp");
-      this.trimEventsToLastCheckout = /* @__PURE__ */ __name((events) => {
-        const lastCheckoutEventIndex = events.reduce(
-          (lastCheckoutEventIndex2, event, index2) => {
-            return event.isCheckout && event.type === EventType.Meta ? index2 : lastCheckoutEventIndex2;
-          },
-          void 0
-        );
-        let trimmedEvents = events;
-        if (lastCheckoutEventIndex !== void 0) {
-          trimmedEvents = events.slice(lastCheckoutEventIndex);
-        }
-        const castedEvents = lastCheckoutEventIndex !== void 0 ? this.liveEvents.slice(0, lastCheckoutEventIndex) : [];
-        return { trimmedEvents, castedEvents, lastCheckoutEventIndex };
-      }, "trimEventsToLastCheckout");
       this.getNodeById = /* @__PURE__ */ __name((id) => {
         return this.replayer.getMirror().getNode(id);
       }, "getNodeById");
       this.getMeta = /* @__PURE__ */ __name((node2) => {
-        return this.replayer.getMirror().getMeta(node2);
+        return this.replayer?.getMirror()?.getMeta(node2);
       }, "getMeta");
+      // store each event for debug and check ids of events and timestamps, if one exists
+      this.debugData = {
+        active: false,
+        events: [],
+        castedEvents: []
+      };
       this.config = { ...this.config, ...config };
-      this.goBackWithEvents = this.goBackWithEvents_native;
     }
     static {
       __name(this, "SessionReplayer");
     }
-    makeReplayerConfig(live, { speed = 8 } = {}) {
+    makeReplayerConfig() {
       const playerConfig = {
         mouseTail: false,
         pauseAnimation: false,
-        speed,
+        speed: 64,
         triggerFocus: true,
         UNSAFE_replayCanvas: true,
-        liveMode: live,
+        liveMode: true,
         showDebug: false,
-        skipInactive: true,
-        inactivePeriodThreshold: 100
+        skipInactive: true
+        // inactivePeriodThreshold: 100,
       };
       if (this.config.root) {
         playerConfig.root = this.config.root;
       }
       return playerConfig;
     }
-    makeReplayer(events, live, { speed = 8 } = {}) {
-      this.replayer = new Replayer(
-        events,
-        this.makeReplayerConfig(live, { speed })
-      );
+    // function to create replayer (should be called once)
+    makeReplayer(events = [], { baselineTime = Date.now() } = {}) {
+      this.replayer = new Replayer(events, this.makeReplayerConfig());
       if (this.config.enableInteract) {
         this.replayer.enableInteract();
       } else {
-        this.replayer.disableInteract();
+        this.replayer?.disableInteract();
       }
-    }
-    start(options, castedEvents = []) {
-      this.startOptions = options;
-      const {
-        firstEventTimestamp,
-        speed = 8,
-        useTimestampCompression = true
-      } = options;
-      this.events = castedEvents;
-      this.numberOfCastedEvents = castedEvents.length;
-      this.makeReplayer([], true, { speed });
-      this.useTimestampCompression = useTimestampCompression;
-      this.replayer.startLive(
-        this.useTimestampCompression ? Date.now() : firstEventTimestamp
-      );
-      this.replayer.on("event-cast", (event) => {
+      if (this.config.onlyLive) {
+        this.replayer.startLive(baselineTime);
+      } else {
+        this.replayer.play();
+      }
+      this.firstEvent = events[0];
+      if (DEBUG_MODE) {
+        this.setupDebugMode();
+      }
+      this.replayer.on(ReplayerEvents.EventCast, (event) => {
+        this.storeCastedEvent(event);
         if (this.onEventCast) {
           this.onEventCast(event);
         }
       });
     }
-    async goLive(sleepAfter = 1e3) {
-      if (this.isLive) {
-        console.log("Already live, nothing to do.");
-        return;
-      }
-      console.log("Going live...");
-      this.stop();
-      this.currentTraveledNumberOfEvents = void 0;
-      const { trimmedEvents, castedEvents } = this.trimEventsToLastCheckout(
-        this.liveEvents
-      );
-      this.start(
-        {
-          ...this.startOptions,
-          firstEventTimestamp: castedEvents.length ? castedEvents[0].timestamp : trimmedEvents[0].timestamp
-        },
-        castedEvents
-      );
-      this.isLive = true;
-      await this.fastForward(trimmedEvents);
-      if (sleepAfter) {
-        await (0, import_await_sleep3.default)(sleepAfter);
-      }
+    seek(ts, pause = true) {
+      return new Promise((resolve2) => {
+        const delta = ts - this.firstEvent.timestamp;
+        this.replayer.play(delta);
+        if (pause) {
+          setTimeout(() => {
+            this.replayer?.pause();
+            resolve2();
+          }, 0);
+        } else {
+          resolve2();
+        }
+      });
     }
-    async goBackWithEvents_native(getEvents2, { sleepAfter = 1e3 }) {
-      if (this.isLive) {
-        this.liveEvents = this.events;
-      }
-      const events = getEvents2();
-      if (events.length === this.currentTraveledNumberOfEvents || events.length < 2) {
-        return;
-      }
-      this.stop();
-      this.events = [];
-      this.numberOfCastedEvents = 0;
-      this.isLive = false;
-      this.currentTraveledNumberOfEvents = events.length;
-      const { trimmedEvents } = this.trimEventsToLastCheckout(events);
-      if (trimmedEvents.length < 2) {
-        console.log("trimmedEvents.length is less than 2");
-        return;
-      }
-      this.makeReplayer(trimmedEvents, false, { speed: 360 });
-      this.replayer.play(trimmedEvents[trimmedEvents.length - 1].timestamp);
-      if (sleepAfter) {
-        await (0, import_await_sleep3.default)(sleepAfter);
-      }
+    start(options, castedEvents = []) {
     }
-    async goBackWithEvents_native2(getEvents2, { sleepAfter = 1e3 }) {
-      try {
-        const events = getEvents2();
-        const targetTimestamp = events[events.length - 1]?.timestamp ?? 0;
-        const getTimeForPause = /* @__PURE__ */ __name(() => {
-          return targetTimestamp - (this.events[0].timestamp ?? 0);
-        }, "getTimeForPause");
-        if (!this.isLive && targetTimestamp <= this.events[this.events.length - 1].timestamp) {
-          const timeForPause2 = getTimeForPause();
-          this.replayer.pause(timeForPause2);
-          return;
-        }
-        if (this.isLive) {
-          this.liveEvents = this.events;
+    // receives new events, and adds them to replayer
+    async fastForward(events) {
+      if (!this.replayer) {
+        if (this.config.onlyLive) {
+          this.makeReplayer([], { baselineTime: events[0].timestamp });
+        } else {
+          this.eventsBuffer.push(...events);
+          if (this.eventsBuffer.length > 2) {
+            this.makeReplayer(this.eventsBuffer);
+          } else {
+            return;
+          }
         }
-        this.stop();
-        this.events = this.liveEvents;
-        this.numberOfCastedEvents = this.liveEvents.length;
-        this.isLive = false;
-        this.makeReplayer(this.events, false, { speed: 360 });
-        const timeForPause = getTimeForPause();
-        this.replayer.pause(timeForPause);
-      } finally {
-        if (sleepAfter) {
-          await (0, import_await_sleep3.default)(sleepAfter);
+      }
+      let numberOfCastedEvents = 0;
+      const promise = new Promise((resolve2) => {
+        this.onEventCast = () => {
+          numberOfCastedEvents++;
+          if (numberOfCastedEvents === events.length) {
+            this.onEventCast = void 0;
+            resolve2();
+          }
+        };
+      });
+      for (const event of events) {
+        if (event.type === EventType.FullSnapshot) {
+          this.lastSnapshot = event;
         }
+        this.replayer.addEvent(event);
+        this.lastEvent = event;
+        this.storeEvent(event);
       }
+      return promise;
     }
-    async goBackWithEvents_FFwd(getEvents2, { sleepAfter = 1e3 }) {
-      if (this.isLive) {
-        this.liveEvents = this.events;
-      }
-      const events = getEvents2();
-      if (events.length === this.currentTraveledNumberOfEvents) {
-        return;
-      }
-      this.currentTraveledNumberOfEvents = events.length;
-      this.stop();
-      const { trimmedEvents, castedEvents } = this.trimEventsToLastCheckout(
-        this.liveEvents
-      );
-      this.start(this.startOptions, castedEvents);
-      this.isLive = false;
-      await this.fastForward(trimmedEvents, true);
-      if (sleepAfter) {
-        await (0, import_await_sleep3.default)(sleepAfter);
-      }
+    async goLive() {
+      await this.seek(this.lastEvent.timestamp, false);
+      await (0, import_await_sleep3.default)(1e3);
     }
     async goBack(timestamp, {
       sleepAfter = 1e3,
       beforeTimestamp = false,
       includeAllMatchingTimestamps = false
     } = {}) {
-      const getEvents2 = /* @__PURE__ */ __name(() => {
-        const indexOfFirstEventWithLargerOrEqualTimestamp = this.liveEvents.findIndex(
-          (e2) => this.getOriginalTimestamp(e2) >= timestamp
-        );
-        const firstEventWithLargerOrEqualTimestamp = this.liveEvents[indexOfFirstEventWithLargerOrEqualTimestamp];
-        if (indexOfFirstEventWithLargerOrEqualTimestamp === -1) {
-          return this.liveEvents;
-        }
-        if (beforeTimestamp || this.getOriginalTimestamp(firstEventWithLargerOrEqualTimestamp) > timestamp) {
-          return this.liveEvents.slice(
-            0,
-            indexOfFirstEventWithLargerOrEqualTimestamp
-          );
-        }
-        if (!includeAllMatchingTimestamps) {
-          return this.liveEvents.slice(
-            0,
-            indexOfFirstEventWithLargerOrEqualTimestamp + 1
-          );
-        }
-        let sliceIndex = indexOfFirstEventWithLargerOrEqualTimestamp + 1;
-        while (sliceIndex < this.liveEvents.length && this.getOriginalTimestamp(this.liveEvents[sliceIndex]) === timestamp) {
-          sliceIndex++;
-        }
-        return this.liveEvents.slice(
-          0,
-          indexOfFirstEventWithLargerOrEqualTimestamp
-        );
-      }, "getEvents");
-      return this.goBackWithEvents(getEvents2, {
-        sleepAfter
-      });
+      await this.seek(timestamp, true);
+      await (0, import_await_sleep3.default)(1e3);
     }
-    async getLastEventTimestamps(snapshot2 = false) {
-      const lastEvent = snapshot2 ? await this.findLastFullSnapshotEvent() : this.events[this.events.length - 1];
-      return {
-        timestamp: lastEvent?.timestamp,
-        originalTimestamp: lastEvent?.originalTimestamp
-      };
+    storeEvent(event) {
+      if (!this.debugData.active) {
+        return;
+      }
+      this.debugData.events.push(event);
     }
-    async findLastFullSnapshotEvent() {
-      const event = this.events.reduce((snapshotEvent, event2) => {
-        return event2.type === EventType.FullSnapshot ? event2 : snapshotEvent;
-      }, void 0);
-      if (event) {
-        return event;
+    storeCastedEvent(event) {
+      if (!this.debugData.active) {
+        return;
       }
-      console.log("waiting for full snapshot event...");
-      await (0, import_await_sleep3.default)(1e3);
-      return this.findLastFullSnapshotEvent();
+      this.debugData.castedEvents.push(event);
+    }
+    setupDebugMode() {
+      this.debugData.active = true;
+      window.__chkreplayer = {
+        events: /* @__PURE__ */ __name(() => this.debugData.events, "events"),
+        back: /* @__PURE__ */ __name((ts) => this.goBack(ts, {}), "back"),
+        currentTime: /* @__PURE__ */ __name(() => this.replayer.getCurrentTime(), "currentTime"),
+        castedEvents: /* @__PURE__ */ __name(() => this.debugData.castedEvents, "castedEvents")
+      };
     }
   };
 
@@ -31758,204 +31632,6 @@
   };
   var elementHighlighter = new ElementHighlighter();
 
-  // ../browser-lib/src/storage/indexedDB.ts
-  var IndexedDBClient = class {
-    constructor(rawDbName, storeName) {
-      this.rawDbName = rawDbName;
-      this.storeName = storeName;
-      this.db = null;
-    }
-    static {
-      __name(this, "IndexedDBClient");
-    }
-    getDBName() {
-      if (!this._dbName) {
-        if (!window.name) {
-          const tabIndex = window.sessionStorage.getItem("nextTabIndex") ?? "0";
-          window.name = tabIndex;
-          window.sessionStorage.setItem(
-            "nextTabIndex",
-            `${parseInt(tabIndex) + 1}`
-          );
-        }
-        this._dbName = `${this.rawDbName}-${window.name}`;
-      }
-      return this._dbName;
-    }
-    open(version = 1) {
-      return new Promise((resolve2, reject) => {
-        const request = indexedDB.open(this.getDBName(), version);
-        request.onupgradeneeded = (event) => {
-          this.db = request.result;
-          if (!this.db.objectStoreNames.contains(this.storeName)) {
-            this.db.createObjectStore(this.storeName);
-          }
-        };
-        request.onsuccess = (event) => {
-          this.db = request.result;
-          resolve2(this.db);
-        };
-        request.onerror = (event) => {
-          console.log("IndexedDBClient.open() error", event, request.error);
-          reject(request.error);
-        };
-      });
-    }
-    count() {
-      return new Promise((resolve2, reject) => {
-        if (!this.db) {
-          reject("Database has not been initialized");
-          return;
-        }
-        const transaction = this.db.transaction([this.storeName]);
-        const store = transaction.objectStore(this.storeName);
-        const request = store.count();
-        request.onsuccess = () => resolve2(request.result);
-        request.onerror = () => {
-          return reject(request.error);
-        };
-      });
-    }
-    set(data, key) {
-      return new Promise((resolve2, reject) => {
-        if (!this.db) {
-          reject("Database has not been initialized");
-          return;
-        }
-        const transaction = this.db.transaction([this.storeName], "readwrite");
-        const store = transaction.objectStore(this.storeName);
-        const request = store.add(data, key);
-        request.onsuccess = () => resolve2();
-        request.onerror = () => {
-          return reject(request.error);
-        };
-      });
-    }
-    get(multiple, query, count) {
-      return new Promise((resolve2, reject) => {
-        if (!this.db) {
-          reject("Database has not been initialized");
-          return;
-        }
-        const transaction = this.db.transaction([this.storeName]);
-        const store = transaction.objectStore(this.storeName);
-        const request = multiple ? store.getAll(query, count) : store.get(query);
-        request.onsuccess = () => resolve2(request.result);
-        request.onerror = () => {
-          return reject(request.error);
-        };
-      });
-    }
-    getOne(query) {
-      return this.get(false, query);
-    }
-    getAll(query, count) {
-      return this.get(true, query, count);
-    }
-  };
-
-  // ../browser-lib/src/rrweb-events-storage-manager/rrweb-events-storage-manager.ts
-  var RrwebEventsStorageManager = class {
-    constructor() {
-      this.initialized = false;
-      this.rrwebEventsLoaded = false;
-      this.loadRRwebEvents = [];
-      this.rrwebCrossFrameEventIdCounter = 0;
-      this.firstRequestedIndex = void 0;
-    }
-    static {
-      __name(this, "RrwebEventsStorageManager");
-    }
-    async initRRwebEvents() {
-      try {
-        if (this.initialized) {
-          console.warn(
-            "[RrwebEventsStorageManager] initRRwebEvents called more than once"
-          );
-          return;
-        }
-        this.initialized = true;
-        this.rrwebEventsIndexedDB = new IndexedDBClient(
-          "checksum",
-          "rrwebEvents"
-        );
-        try {
-          await this.rrwebEventsIndexedDB.open();
-        } catch (e2) {
-          return;
-        }
-        this.rrwebCrossFrameEventIdCounter = await this.rrwebEventsIndexedDB.count();
-        this.loadRRwebEvents.forEach((event) => {
-          this.rrwebEventsIndexedDB.set(
-            event,
-            this.rrwebCrossFrameEventIdCounter++
-          );
-        });
-        this.rrwebEventsLoaded = true;
-      } catch (e2) {
-        console.log(e2);
-      }
-    }
-    onRRwebEvent(event) {
-      if (this.rrwebEventsLoaded) {
-        this.rrwebEventsIndexedDB.set(
-          event,
-          this.rrwebCrossFrameEventIdCounter++
-        );
-      } else {
-        this.loadRRwebEvents.push(event);
-      }
-    }
-    isInitialized() {
-      return this.initialized;
-    }
-    getLastRRwebEventKey() {
-      return this.rrwebCrossFrameEventIdCounter - 1;
-    }
-    /**
-     * Performs an HTTP post with the JSON of the rrweb events array to a given URL.
-     */
-    async postRRwebEvents(url) {
-      if (!this.rrwebEventsLoaded) {
-        return [];
-      }
-      const rrwebEvents = await this.rrwebEventsIndexedDB.getAll();
-      return fetch(url, {
-        method: "PUT",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(rrwebEvents)
-      });
-    }
-    async getRRwebEvents(lowerBoundKey, size) {
-      try {
-        if (this.firstRequestedIndex === void 0) {
-          this.firstRequestedIndex = lowerBoundKey;
-        }
-        lowerBoundKey -= this.firstRequestedIndex;
-        if (!this.rrwebEventsLoaded) {
-          return [];
-        }
-        const bound = size ? IDBKeyRange.bound(lowerBoundKey, lowerBoundKey + size) : IDBKeyRange.lowerBound(lowerBoundKey);
-        const events = await this.rrwebEventsIndexedDB.getAll(
-          bound
-        );
-        return events;
-      } catch (e2) {
-        console.log(e2);
-        return [];
-      }
-    }
-    async getRRwebEvent(key) {
-      if (!this.rrwebEventsLoaded) {
-        return null;
-      }
-      return this.rrwebEventsIndexedDB.getOne(key);
-    }
-  };
-  var rrwebEventsStorageManager = new RrwebEventsStorageManager();
-
   // src/lib/test-generator/selectors/pw-injected-script-functions.js
   function escapeForTextSelector(text, exact) {
     if (typeof text !== "string") return escapeRegexForSelector(text);
@@ -32026,11 +31702,6 @@
     return selector.trim().replace(/([!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~])/g, "\\$1");
   }
   __name(escapeSelector, "escapeSelector");
-  function replaceLocatorQuotesWithTicks(str) {
-    const firstParantheses = str.indexOf("(");
-    return str.substring(0, firstParantheses + 1) + "`" + str.substring(firstParantheses + 2, str.length - 2) + "`)";
-  }
-  __name(replaceLocatorQuotesWithTicks, "replaceLocatorQuotesWithTicks");
   function getElementWindowPlaywright(node2) {
     const elementWindow = node2.ownerDocument.defaultView;
     if (elementWindow !== window && !elementWindow.playwright) {
@@ -32755,7 +32426,7 @@
   }, "guardReturn");
 
   // src/lib/test-generator/selectors/pw-custom-locator-generator.ts
-  var DEBUG_MODE = false;
+  var DEBUG_MODE2 = false;
   var LocatorChain = class _LocatorChain {
     constructor(locators) {
       this.locators = [];
@@ -32924,7 +32595,7 @@
         }
       } catch (error) {
         if (error instanceof TimeoutError) {
-          console.log("Timeout error");
+          console.warn("[PlaywrightCustomLocatorGenerator] Timeout error");
         }
       }
       if (!filteredCandidates?.length) {
@@ -32972,11 +32643,12 @@
      *
      * @param selector selector to test
      * @param element element to test the selector on
-     * @param testVariables object containing variables information to test the selector with
+     * @param testVariables object containing variables information to test the locator with
      * @param testUniqueness test if selector returns only one element
      * @returns object with valid flag and locator candidate if valid
      */
-    testSelector(selector, element, testVariables, testUniqueness = true) {
+    testSelector(locator, element, testVariables, testUniqueness = true) {
+      const selector = getElementWindowPlaywright(element).selector(element);
       const locatorResult = this.getLocatorBase(element).locator(selector);
       console.log("Locator result", locatorResult);
       const testResult = /* @__PURE__ */ __name((locatorResult2) => {
@@ -32991,10 +32663,10 @@
         return { valid: false };
       }
       let variableSelectionData = {};
-      if (testVariables?.selectorWithVars?.length) {
+      if (testVariables?.locatorWithVars?.length) {
         try {
           const func = new Function(
-            `{ return function(element) { ${testVariables.variablesCode}; return this.getLocatorBase(element).locator(\`${testVariables.selectorWithVars}\`); } }`
+            `{ return function(element) { ${testVariables.variablesCode}; return this.getLocatorBase(element).locator(\`${testVariables.locatorWithVars}\`); } }`
           );
           const res = func().call(this, element);
           console.log("Locator with vars result", res);
@@ -33002,10 +32674,12 @@
             return { valid: false };
           }
           variableSelectionData = {
-            selectorWithVars: testVariables.selectorWithVars,
-            locatorWithVars: replaceLocatorQuotesWithTicks(
-              this.getSelectorLocator(testVariables.selectorWithVars, element)
-            )
+            selectorWithVars: selector,
+            // TODO: selector with vars is similar to selector, should be different
+            locatorWithVars: testVariables.locatorWithVars
+            //   locatorWithVars: replaceLocatorQuotesWithTicks(
+            //     this.getSelectorLocator(testVariables.selectorWithVars, element)
+            //   ),
           };
         } catch (error) {
           console.error("Error testing selector with variables", error.message);
@@ -33015,7 +32689,7 @@
       return {
         valid: true,
         selector,
-        locator: this.getSelectorLocator(selector, element),
+        locator,
         ...variableSelectionData
       };
     }
@@ -33430,7 +33104,7 @@
       const selector = tag + innerFeatures.map((feature) => `:has(${feature})`).join("");
       return {
         selector,
-        locator: `locator('${tag}', {has: page.locator('${selector}')})`
+        locator: this.getSelectorLocator(selector)
       };
     }
     getByRoleLocator(element, options = {}) {
@@ -33498,9 +33172,10 @@
           props.push(["name", escapeForAttributeSelector(name, exact)]);
         }
         const getSelection = /* @__PURE__ */ __name(() => {
+          const selector = `internal:role=${role}${props.map(([n2, v2]) => `[${n2}=${v2}]`).join("")}`;
           return {
-            locator: `getByRole('${role}', { ${props.join(", ")} })`,
-            selector: `internal:role=${role}${props.map(([n2, v2]) => `[${n2}=${v2}]`).join("")}`,
+            locator: this.getSelectorLocator(selector),
+            selector,
             options: usedFilters
           };
         }, "getSelection");
@@ -33553,7 +33228,6 @@
         let selection = getSelection(options.exact);
         if (options.exact && !this.getLocatorBase(element).locator(selection.selector).elements.includes(element)) {
           selection = getSelection(false);
-          4;
         }
         return selection;
       } catch (error) {
@@ -33657,7 +33331,7 @@
       return { text, exact };
     }
     checkTimeout(throwError = true) {
-      if (DEBUG_MODE) {
+      if (DEBUG_MODE2) {
         return false;
       }
       if (this.MAX_PROCESSING_TIME && Date.now() - this.startTimestamp > this.MAX_PROCESSING_TIME) {
@@ -33677,6 +33351,68 @@
   }
   __name(isInstanceOfHTMLElement, "isInstanceOfHTMLElement");
 
+  // ../browser-lib/src/helpers/dom/xpath.ts
+  function getRelativeXPath(element = document, child) {
+    try {
+      let getNodeIdentifier2 = function(node3) {
+        let identifier = node3.nodeName.toLowerCase();
+        let foundAttributeIdentifier = false;
+        ["name", "label", "aria-label", "data-testid", "role"].forEach((attr) => {
+          if (node3.hasAttribute(attr)) {
+            identifier += `[@${attr}="${node3.getAttribute(attr)}"]`;
+            foundAttributeIdentifier = true;
+          }
+        });
+        if (!foundAttributeIdentifier) {
+          let index2 = 1;
+          let sibling = node3.previousSibling;
+          while (sibling) {
+            if (sibling.nodeType === Node.ELEMENT_NODE && sibling.nodeName === node3.nodeName) {
+              index2++;
+            }
+            sibling = sibling.previousSibling;
+          }
+          if (index2 > 1) {
+            identifier += `[${index2}]`;
+          }
+        }
+        return identifier;
+      };
+      var getNodeIdentifier = getNodeIdentifier2;
+      __name(getNodeIdentifier2, "getNodeIdentifier");
+      if (!element || !child || !element.contains(child)) {
+        throw new Error("Child is not a descendant of the given element.");
+      }
+      let path = [];
+      let node2 = child;
+      while (node2 !== element) {
+        if (node2.nodeType === Node.ELEMENT_NODE) {
+          path.unshift(getNodeIdentifier2(node2));
+        }
+        node2 = node2.parentElement;
+      }
+      return path.join("/");
+    } catch (error) {
+      console.error("Failed to get relative xpath", error);
+      return;
+    }
+  }
+  __name(getRelativeXPath, "getRelativeXPath");
+  function findElementsByXPath(parentElement2, xpath) {
+    let evaluator = new XPathEvaluator();
+    let result2 = evaluator.evaluate(
+      xpath,
+      parentElement2,
+      null,
+      XPathResult.FIRST_ORDERED_NODE_TYPE,
+      null
+    );
+    return [result2.singleNodeValue].filter(
+      (node2) => node2 instanceof HTMLElement
+    );
+  }
+  __name(findElementsByXPath, "findElementsByXPath");
+
   // src/lib/test-generator/selectors/compound-selector.ts
   var CLASS_IGNORE_LIST = [
     ":hover",
@@ -33767,7 +33503,7 @@
       const compoundSelector = {
         // generate selectors from the common root to the target element
         targetSelection: {
-          xpath: this.getRelativeXPath(commonRoot, targetElement.element),
+          xpath: getRelativeXPath(commonRoot, targetElement.element),
           cssSelectors: this.generateAllContextualSelectors(
             commonRoot,
             targetElement.element
@@ -33861,7 +33597,7 @@
       if (targetSelection.xpath) {
         try {
           addElementstoHistogram(
-            this.findElementsByXPath(commonParent, targetSelection.xpath)
+            findElementsByXPath(commonParent, targetSelection.xpath)
           );
         } catch (error) {
         }
@@ -34025,68 +33761,6 @@
       });
       return [...new Set(selectors)];
     }
-    /**
-     * Builds relative xpath from an element to its child
-     */
-    getRelativeXPath(element, child) {
-      try {
-        let getNodeIdentifier = function(node3) {
-          let identifier = node3.nodeName.toLowerCase();
-          let foundAttributeIdentifier = false;
-          ["name", "label", "aria-label", "data-testid", "role"].forEach(
-            (attr) => {
-              if (node3.hasAttribute(attr)) {
-                identifier += `[@${attr}="${node3.getAttribute(attr)}"]`;
-                foundAttributeIdentifier = true;
-              }
-            }
-          );
-          if (!foundAttributeIdentifier) {
-            let index2 = 1;
-            let sibling = node3.previousSibling;
-            while (sibling) {
-              if (sibling.nodeType === Node.ELEMENT_NODE && sibling.nodeName === node3.nodeName) {
-                index2++;
-              }
-              sibling = sibling.previousSibling;
-            }
-            if (index2 > 1) {
-              identifier += `[${index2}]`;
-            }
-          }
-          return identifier;
-        };
-        __name(getNodeIdentifier, "getNodeIdentifier");
-        if (!element || !child || !element.contains(child)) {
-          throw new Error("Child is not a descendant of the given element.");
-        }
-        let path = [];
-        let node2 = child;
-        while (node2 !== element) {
-          if (node2.nodeType === Node.ELEMENT_NODE) {
-            path.unshift(getNodeIdentifier(node2));
-          }
-          node2 = node2.parentElement;
-        }
-        return path.join("/");
-      } catch (error) {
-        console.error("Failed to get relative xpath", error);
-        return;
-      }
-    }
-    findElementsByXPath(parentElement2, xpath) {
-      let evaluator = new XPathEvaluator();
-      let result2 = evaluator.evaluate(
-        xpath,
-        parentElement2,
-        null,
-        XPathResult.FIRST_ORDERED_NODE_TYPE,
-        null
-      );
-      return [result2.singleNodeValue].filter(
-        (node2) => node2 instanceof HTMLElement
-      );
-    }
     /**
      * Create a contextual selector from the common root to the target element
      * We can play with the options to build various types of selectors which we could
@@ -34284,8 +33958,6 @@
           );
           attributeMaxSize = Math.max(attributeMaxSize - 10, 0);
         } while (rootClone.outerHTML.length > this.MAX_SNIPPET_SIZE && attributeMaxSize > 0);
-        rootClone.querySelectorAll("*").forEach((el) => {
-        });
         let htmlSnippet = serializeElement(rootClone, {
           limitAttributeLength: true
         });
@@ -34872,14 +34544,14 @@ ${data.locator}`
     /**
      * Tests a selector for a given element.
      */
-    testElementSelector(selector, element, testVariables, testUniqueness = true) {
+    testElementSelector(locator, element, testVariables, testUniqueness = true) {
       const testElement = typeof element === "string" ? this.htmlReducer.getElementForChecksumId(element) : element;
       if (!testElement) {
         console.error("Element not found", element);
         return { valid: false, error: "Element not found" };
       }
       return new PlaywrightCustomLocatorGenerator().testSelector(
-        selector,
+        locator,
         testElement,
         testVariables,
         testUniqueness
@@ -34925,9 +34597,9 @@ ${data.locator}`
         this.sessionMirror = new SessionRecorder((event, isCheckout) => {
           event.isCheckout = isCheckout;
           window.checksumSendBroadcastMessage?.("rrweb", [event]);
-          rrwebEventsStorageManager.onRRwebEvent(event);
+          this.lastRrwebEventTimestamp = event.timestamp;
+          console.log(event.timestamp);
         }, config.recordOptions);
-        rrwebEventsStorageManager.initRRwebEvents();
       }
       if (initFilesObserver) {
         this.filesObserver = new FilesObserver(this.sessionMirror);
@@ -35131,12 +34803,12 @@ ${data.locator}`
     /**
      * Performs an HTTP post with the JSON of the rrweb events array to a given URL.
      */
-    async postRRwebEvents(url) {
-      return rrwebEventsStorageManager.postRRwebEvents(url);
-    }
-    async getRRwebEvents(id) {
-      return rrwebEventsStorageManager.getRRwebEvents(id);
-    }
+    // async postRRwebEvents(url) {
+    //   return rrwebEventsStorageManager.postRRwebEvents(url);
+    // }
+    // async getRRwebEvents(id: number) {
+    //   return rrwebEventsStorageManager.getRRwebEvents(id);
+    // }
     /**
      * Function used to reduce the HTML of the page to a minimal set of elements that are required
      * to produce a prompt for the LLM agent.
@@ -35150,17 +34822,10 @@ ${data.locator}`
         { ...this.appSpecificRules, ...appSpecificRules },
         options
       );
-      const rrwebEventKey = rrwebEventsStorageManager.isInitialized() ? rrwebEventsStorageManager.getLastRRwebEventKey() : void 0;
-      if (rrwebEventKey) {
-        const rrwebEvent = await rrwebEventsStorageManager.getRRwebEvent(
-          rrwebEventKey
-        );
-        if (rrwebEvent) {
-          reducedHTMLData.lastRRwebEvent = {
-            key: rrwebEventKey,
-            timestamp: rrwebEvent.timestamp
-          };
-        }
+      if (this.lastRrwebEventTimestamp) {
+        reducedHTMLData.lastRRwebEvent = {
+          timestamp: this.lastRrwebEventTimestamp
+        };
       }
       if (options.extractESRAForInterpretationRequiredElements) {
         console.log("Extracting ESRA for interpretation required elements...");
@@ -35798,9 +35463,6 @@ ${data.locator}`
     goLive() {
       return this.sessionReplayer.goLive();
     }
-    getLastEventTimestamps(snapshot2 = false) {
-      return this.sessionReplayer.getLastEventTimestamps(snapshot2);
-    }
   };
 
   // ../browser-lib/src/visual-test-generator/time-machine-event-handlers.ts
@@ -35833,7 +35495,6 @@ ${data.locator}`
         }
       }
       if (extractPlaywrightSelector) {
-        console.log("extracting playwright selector...");
         const {
           selector: playwrightSelector,
           locator,
@@ -35844,7 +35505,6 @@ ${data.locator}`
         selector.playwrightSelector = playwrightSelector;
         selector.playwrightLocator = locator;
         selector.playwrightParentFramesSelectors = parentFramesSelectors;
-        console.log("Playwright selector extraction complete");
       }
       return selector;
     }
@@ -36088,7 +35748,8 @@ ${data.locator}`
                   selector: dropzoneSelector.playwrightSelector,
                   locator: dropzoneSelector.playwrightLocator,
                   parentFramesSelectors: dropzoneSelector.playwrightParentFramesSelectors,
-                  esraMetadata: dropzoneSelector.esraMetadata
+                  esraMetadata: dropzoneSelector.esraMetadata,
+                  rrwebId: dropzoneNodeId
                 }
               }
             )
@@ -36109,7 +35770,8 @@ ${data.locator}`
       window.parent.document.body.appendChild(liveTMDiv);
       this.sessionReplayer = new SessionReplayer({
         enableInteract: false,
-        root: liveTMDiv
+        root: liveTMDiv,
+        onlyLive: true
       });
       this.sessionReplayer.start({ firstEventTimestamp: Date.now() });
     }
@@ -36355,6 +36017,9 @@ ${data.locator}`
         pageId: void 0,
         timestamp: event.timestamp,
         id: data?.id || Date.now().toString(),
+        // @ts-ignore
+        rrwebId: event.data?.id,
+        // add rrwebId for services caching
         ...data
       };
     }
@@ -36401,7 +36066,10 @@ ${data.locator}`
       if (!node2) {
         return {};
       }
-      const selector = await this.elementSelector.getSelector(node2);
+      const selector = await this.elementSelector.getSelector(node2, {
+        extractEsraMetadata: false
+        // For now, don't produce ESRA metadata for VTG steps recording
+      });
       if (!selector) {
         return { node: node2 };
       }