@opensteer/engine-playwright 0.8.2 → 0.8.4

package/dist/index.js

@@ -1277,19 +1277,24 @@ function normalizePostLoadTrackerState(value) {
   const installedAt = readFiniteNumber(value.installedAt);
   const lastMutationAt = readFiniteNumber(value.lastMutationAt);
   const lastNetworkActivityAt = readFiniteNumber(value.lastNetworkActivityAt);
+  const lastTrackedNetworkActivityAt = readFiniteNumber(value.lastTrackedNetworkActivityAt);
   const now = readFiniteNumber(value.now);
   const readyState = typeof value.readyState === "string" ? value.readyState : void 0;
-  if (installedAt === void 0 || lastMutationAt === void 0 || lastNetworkActivityAt === void 0 || now === void 0 || readyState === void 0) {
+  if (installedAt === void 0 || lastMutationAt === void 0 || lastNetworkActivityAt === void 0 || lastTrackedNetworkActivityAt === void 0 || now === void 0 || readyState === void 0) {
     return void 0;
   }
   return {
     installedAt,
     lastMutationAt,
     lastNetworkActivityAt,
+    lastTrackedNetworkActivityAt,
     now,
     pendingFetches: readNonNegativeNumber(value.pendingFetches),
     pendingTimeouts: readNonNegativeNumber(value.pendingTimeouts),
     pendingXhrs: readNonNegativeNumber(value.pendingXhrs),
+    trackedPendingFetches: readNonNegativeNumber(value.trackedPendingFetches),
+    trackedPendingXhrs: readNonNegativeNumber(value.trackedPendingXhrs),
+    collecting: value.collecting === true,
     readyState
   };
 }
@@ -1304,11 +1309,14 @@ function buildPostLoadTrackerInstallScript() {
       installedAt: performance.now(),
       lastMutationAt: performance.now(),
       lastNetworkActivityAt: performance.now(),
+      lastTrackedNetworkActivityAt: performance.now(),
       pendingFetches: 0,
       pendingTimeouts: 0,
       pendingXhrs: 0,
+      trackedPendingFetches: 0,
+      trackedPendingXhrs: 0,
+      collecting: true,
       readyState: document.readyState,
-      timeoutIds: new Set(),
     };
     globalObject.__opensteerActionBoundaryTrackerInstalled = true;
     globalObject.__opensteerActionBoundaryTracker = tracker;
@@ -1321,6 +1329,18 @@ function buildPostLoadTrackerInstallScript() {
       tracker.lastNetworkActivityAt = performance.now();
       tracker.readyState = document.readyState;
     };
+    const markTrackedNetwork = () => {
+      tracker.lastTrackedNetworkActivityAt = performance.now();
+      markNetwork();
+    };
+    const resetTracking = () => {
+      const now = performance.now();
+      tracker.lastTrackedNetworkActivityAt = now;
+      tracker.trackedPendingFetches = 0;
+      tracker.trackedPendingXhrs = 0;
+      tracker.collecting = true;
+      tracker.readyState = document.readyState;
+    };
 
     const startObserver = () => {
       const target = document.documentElement ?? document;
@@ -1346,45 +1366,26 @@ function buildPostLoadTrackerInstallScript() {
     document.addEventListener("readystatechange", markMutation);
     addEventListener("load", markMutation, { once: true });
 
-    const nativeSetTimeout = globalObject.setTimeout.bind(globalObject);
-    const nativeClearTimeout = globalObject.clearTimeout.bind(globalObject);
-    globalObject.setTimeout = function(callback, delay, ...args) {
-      tracker.pendingTimeouts += 1;
-      markNetwork();
-      let handle;
-      const wrapped =
-        typeof callback === "function"
-          ? (...callbackArgs) => {
-              if (tracker.timeoutIds.delete(handle)) {
-                tracker.pendingTimeouts = Math.max(0, tracker.pendingTimeouts - 1);
-              }
-              try {
-                return callback(...callbackArgs);
-              } finally {
-                markMutation();
-              }
-            }
-          : callback;
-      handle = nativeSetTimeout(wrapped, delay, ...args);
-      tracker.timeoutIds.add(handle);
-      return handle;
-    };
-    globalObject.clearTimeout = function(handle) {
-      if (tracker.timeoutIds.delete(handle)) {
-        tracker.pendingTimeouts = Math.max(0, tracker.pendingTimeouts - 1);
-      }
-      return nativeClearTimeout(handle);
-    };
-
     if (typeof globalObject.fetch === "function") {
       const nativeFetch = globalObject.fetch.bind(globalObject);
       globalObject.fetch = (...args) => {
+        const tracked = tracker.collecting === true;
         tracker.pendingFetches += 1;
-        markNetwork();
+        if (tracked) {
+          tracker.trackedPendingFetches += 1;
+          markTrackedNetwork();
+        } else {
+          markNetwork();
+        }
         return nativeFetch(...args)
           .finally(() => {
             tracker.pendingFetches = Math.max(0, tracker.pendingFetches - 1);
-            markNetwork();
+            if (tracked) {
+              tracker.trackedPendingFetches = Math.max(0, tracker.trackedPendingFetches - 1);
+              markTrackedNetwork();
+            } else {
+              markNetwork();
+            }
           });
       };
     }
@@ -1393,21 +1394,60 @@ function buildPostLoadTrackerInstallScript() {
       const NativeXMLHttpRequest = globalObject.XMLHttpRequest;
       const nativeSend = NativeXMLHttpRequest.prototype.send;
       NativeXMLHttpRequest.prototype.send = function(...args) {
+        const tracked = tracker.collecting === true;
         tracker.pendingXhrs += 1;
-        markNetwork();
+        if (tracked) {
+          tracker.trackedPendingXhrs += 1;
+          markTrackedNetwork();
+        } else {
+          markNetwork();
+        }
         const finalize = () => {
           this.removeEventListener("loadend", finalize);
           tracker.pendingXhrs = Math.max(0, tracker.pendingXhrs - 1);
-          markNetwork();
+          if (tracked) {
+            tracker.trackedPendingXhrs = Math.max(0, tracker.trackedPendingXhrs - 1);
+            markTrackedNetwork();
+          } else {
+            markNetwork();
+          }
         };
         this.addEventListener("loadend", finalize, { once: true });
         return nativeSend.apply(this, args);
       };
     }
 
+    tracker.beginObservation = () => {
+      resetTracking();
+      return true;
+    };
+    tracker.freezeObservation = () => {
+      tracker.collecting = false;
+      tracker.readyState = document.readyState;
+      return true;
+    };
+
     return true;
   })()`;
 }
+function buildPostLoadTrackerBeginExpression() {
+  return `(() => {
+    const tracker = globalThis.__opensteerActionBoundaryTracker;
+    if (!tracker || typeof tracker.beginObservation !== "function") {
+      return false;
+    }
+    return tracker.beginObservation();
+  })()`;
+}
+function buildPostLoadTrackerFreezeExpression() {
+  return `(() => {
+    const tracker = globalThis.__opensteerActionBoundaryTracker;
+    if (!tracker || typeof tracker.freezeObservation !== "function") {
+      return false;
+    }
+    return tracker.freezeObservation();
+  })()`;
+}
 function buildPostLoadTrackerReadExpression() {
   return `(() => {
     const tracker = globalThis.__opensteerActionBoundaryTracker;
@@ -1419,14 +1459,31 @@ function buildPostLoadTrackerReadExpression() {
       installedAt: Number(tracker.installedAt ?? 0),
       lastMutationAt: Number(tracker.lastMutationAt ?? 0),
       lastNetworkActivityAt: Number(tracker.lastNetworkActivityAt ?? 0),
+      lastTrackedNetworkActivityAt: Number(tracker.lastTrackedNetworkActivityAt ?? 0),
       now: Number(performance.now()),
       pendingFetches: Number(tracker.pendingFetches ?? 0),
       pendingTimeouts: Number(tracker.pendingTimeouts ?? 0),
       pendingXhrs: Number(tracker.pendingXhrs ?? 0),
+      trackedPendingFetches: Number(tracker.trackedPendingFetches ?? 0),
+      trackedPendingXhrs: Number(tracker.trackedPendingXhrs ?? 0),
+      collecting: tracker.collecting === true,
       readyState: String(document.readyState),
     };
   })()`;
 }
+function capturePostLoadTrackerSnapshot(tracker) {
+  return {
+    lastTrackedNetworkActivityAt: tracker.lastTrackedNetworkActivityAt,
+    trackedPendingFetches: tracker.trackedPendingFetches,
+    trackedPendingXhrs: tracker.trackedPendingXhrs
+  };
+}
+function postLoadTrackerHasTrackedNetworkActivitySince(snapshot, tracker) {
+  if (!tracker) {
+    return false;
+  }
+  return tracker.trackedPendingFetches > snapshot.trackedPendingFetches || tracker.trackedPendingXhrs > snapshot.trackedPendingXhrs || tracker.lastTrackedNetworkActivityAt > snapshot.lastTrackedNetworkActivityAt;
+}
 function postLoadTrackerIsSettled(tracker, quietWindowMs = DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS) {
   if (!tracker) {
     return false;
@@ -1434,13 +1491,13 @@ function postLoadTrackerIsSettled(tracker, quietWindowMs = DEFAULT_POST_LOAD_TRA
   if (tracker.readyState !== "complete") {
     return false;
   }
-  if (tracker.pendingFetches > 0 || tracker.pendingTimeouts > 0 || tracker.pendingXhrs > 0) {
+  if (tracker.trackedPendingFetches > 0 || tracker.trackedPendingXhrs > 0) {
     return false;
   }
   const lastActivityAt = Math.max(
     tracker.installedAt,
     tracker.lastMutationAt,
-    tracker.lastNetworkActivityAt
+    tracker.lastTrackedNetworkActivityAt
   );
   return tracker.now - lastActivityAt >= quietWindowMs;
 }
@@ -1462,7 +1519,7 @@ async function waitForActionBoundary(input) {
   const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_ACTION_BOUNDARY_POLL_INTERVAL_MS;
   let trigger = "dom-action";
   let crossDocument = false;
-  let waitedForNavigationContentLoaded = false;
+  let sameDocumentAsyncActivity = false;
   while (Date.now() < deadline) {
     input.throwBackgroundError();
     if (input.isPageClosed()) {
@@ -1484,16 +1541,21 @@ async function waitForActionBoundary(input) {
       throw abortError(input.signal);
     }
     const currentDocumentRef = input.getCurrentMainFrameDocumentRef();
+    const currentPageUrl = input.getCurrentPageUrl?.();
     if (input.snapshot !== void 0 && currentDocumentRef !== void 0 && currentDocumentRef !== input.snapshot.documentRef) {
       trigger = "navigation";
       crossDocument = true;
-      if (!waitedForNavigationContentLoaded) {
-        waitedForNavigationContentLoaded = true;
-        const remaining = Math.max(0, deadline - Date.now());
-        if (remaining > 0) {
-          await input.waitForNavigationContentLoaded(remaining);
-        }
-      }
+    }
+    if (!crossDocument && !sameDocumentAsyncActivity && input.snapshot?.tracker !== void 0 && postLoadTrackerHasTrackedNetworkActivitySince(
+      input.snapshot.tracker,
+      await input.readTrackerState()
+    )) {
+      trigger = "navigation";
+      sameDocumentAsyncActivity = true;
+    }
+    if (!crossDocument && input.snapshot?.url !== void 0 && currentPageUrl !== void 0 && currentPageUrl !== input.snapshot.url && input.isCurrentMainFrameBootstrapSettled !== void 0 && !input.isCurrentMainFrameBootstrapSettled()) {
+      trigger = "navigation";
+      crossDocument = true;
     }
     if (!crossDocument && crossDocumentDetectionDeadline !== void 0 && Date.now() >= crossDocumentDetectionDeadline) {
       return {
@@ -1502,7 +1564,18 @@ async function waitForActionBoundary(input) {
         bootstrapSettled: true
       };
     }
-    if (crossDocument && postLoadTrackerIsSettled(await input.readTrackerState())) {
+    if (sameDocumentAsyncActivity) {
+      return {
+        trigger,
+        crossDocument,
+        bootstrapSettled: true
+      };
+    }
+    if (crossDocument && input.isCurrentMainFrameBootstrapSettled !== void 0 && !input.isCurrentMainFrameBootstrapSettled()) {
+      await delay(Math.min(pollIntervalMs, Math.max(0, deadline - Date.now())));
+      continue;
+    }
+    if (crossDocument) {
       return {
         trigger,
         crossDocument,
@@ -3437,6 +3510,7 @@ async function releaseObject(controller, objectId) {
 
 // src/action-settle.ts
 var DEFAULT_PLAYWRIGHT_ACTION_SETTLE_TIMEOUT_MS = CROSS_DOCUMENT_INTERACTION_TIMEOUT_MS;
+var DEFAULT_PLAYWRIGHT_POST_LOAD_CAPTURE_WINDOW_MS = 1e3;
 function clampPlaywrightActionSettleTimeout(timeoutMs) {
   if (timeoutMs === void 0) {
     return DEFAULT_PLAYWRIGHT_ACTION_SETTLE_TIMEOUT_MS;
@@ -3445,6 +3519,8 @@ function clampPlaywrightActionSettleTimeout(timeoutMs) {
 }
 function createPlaywrightActionSettler(context) {
   const installScript = buildPostLoadTrackerInstallScript();
+  const beginExpression = buildPostLoadTrackerBeginExpression();
+  const freezeExpression = buildPostLoadTrackerFreezeExpression();
   const readExpression = buildPostLoadTrackerReadExpression();
   async function installTracker(controller) {
     if (!controller.settleTrackerRegistered) {
@@ -3479,6 +3555,79 @@ function createPlaywrightActionSettler(context) {
       throw normalizePlaywrightError(error, controller.pageRef);
     }
   }
+  async function beginTrackerObservation(controller) {
+    await installTracker(controller);
+    try {
+      await controller.cdp.send("Runtime.evaluate", {
+        expression: beginExpression,
+        returnByValue: true,
+        awaitPromise: true
+      });
+    } catch (error) {
+      if (isIgnorableTrackerReadError(error)) {
+        return;
+      }
+      throw normalizePlaywrightError(error, controller.pageRef);
+    }
+  }
+  async function freezeTrackerObservation(controller) {
+    try {
+      await controller.cdp.send("Runtime.evaluate", {
+        expression: freezeExpression,
+        returnByValue: true,
+        awaitPromise: true
+      });
+    } catch (error) {
+      if (isIgnorableTrackerReadError(error)) {
+        return;
+      }
+      throw normalizePlaywrightError(error, controller.pageRef);
+    }
+  }
+  async function captureSnapshot(controller) {
+    const documentRef = context.getMainFrameDocumentRef(controller);
+    if (documentRef === void 0) {
+      throw new Error(`page ${controller.pageRef} does not expose a main frame`);
+    }
+    await beginTrackerObservation(controller);
+    const tracker = await readTrackerState(controller);
+    return {
+      pageRef: controller.pageRef,
+      documentRef,
+      url: controller.page.url(),
+      ...tracker === void 0 ? {} : { tracker: capturePostLoadTrackerSnapshot(tracker) }
+    };
+  }
+  async function waitForPostLoadQuiet(input) {
+    const { controller, timeoutMs, signal } = input;
+    if (timeoutMs <= 0) {
+      return;
+    }
+    const quietMs = input.quietMs ?? DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS;
+    const captureWindowMs = Math.max(
+      0,
+      Math.min(input.captureWindowMs ?? DEFAULT_PLAYWRIGHT_POST_LOAD_CAPTURE_WINDOW_MS, timeoutMs)
+    );
+    const deadline = Date.now() + timeoutMs;
+    await installTracker(controller);
+    if (captureWindowMs > 0) {
+      await delayWithSignal2(captureWindowMs, signal, deadline);
+    }
+    await freezeTrackerObservation(controller);
+    while (Date.now() < deadline) {
+      if (signal?.aborted) {
+        throw signal.reason ?? abortError2();
+      }
+      context.throwBackgroundError(controller);
+      if (controller.lifecycleState === "closed") {
+        return;
+      }
+      if (postLoadTrackerIsSettled(await readTrackerState(controller), quietMs)) {
+        return;
+      }
+      await delayWithSignal2(100, signal, deadline);
+    }
+  }
   async function settle(options) {
     const { controller, timeoutMs, signal, snapshot, policySettle } = options;
     if (timeoutMs <= 0) {
@@ -3510,18 +3659,8 @@ function createPlaywrightActionSettler(context) {
         ...signal === void 0 ? {} : { signal },
         snapshot,
         getCurrentMainFrameDocumentRef: () => context.getMainFrameDocumentRef(controller),
-        waitForNavigationContentLoaded: async (remainingMs) => {
-          try {
-            await controller.page.waitForLoadState("domcontentloaded", {
-              timeout: remainingMs
-            });
-          } catch (error) {
-            if (controller.lifecycleState === "closed" || isContextClosedError(error)) {
-              return;
-            }
-            throw normalizePlaywrightError(error, controller.pageRef);
-          }
-        },
+        getCurrentPageUrl: () => controller.page.url(),
+        isCurrentMainFrameBootstrapSettled: () => context.isCurrentMainFrameBootstrapSettled(controller),
         readTrackerState: () => readTrackerState(controller),
         throwBackgroundError: () => context.throwBackgroundError(controller),
         isPageClosed: () => controller.lifecycleState === "closed"
@@ -3537,13 +3676,36 @@ function createPlaywrightActionSettler(context) {
     return boundary;
   }
   return {
+    captureSnapshot,
     installTracker,
+    waitForPostLoadQuiet,
     settle
   };
 }
 function abortError2() {
   return new DOMException("The operation was aborted", "AbortError");
 }
+async function delayWithSignal2(delayMs, signal, deadline) {
+  const effectiveDelay = Math.max(0, Math.min(delayMs, Math.max(0, deadline - Date.now())));
+  if (effectiveDelay <= 0) {
+    return;
+  }
+  if (signal?.aborted) {
+    throw signal.reason ?? abortError2();
+  }
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, effectiveDelay);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(signal?.reason ?? abortError2());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function isIgnorableTrackerReadError(error) {
   return isContextClosedError(error) || error instanceof Error && /Execution context was destroyed|Cannot find context|Inspected target navigated or closed/i.test(
     error.message
@@ -3741,6 +3903,71 @@ function cloneKeyPath(keyPath) {
 }
 
 // src/engine.ts
+var PLAYWRIGHT_RUNTIME_EVENT_RECORDER_SOURCE = String.raw`(() => {
+  const key = "__opensteerRuntimeEventRecorder";
+  const globalScope = globalThis;
+  if (globalScope[key]?.installed === true) {
+    return;
+  }
+
+  const queue = [];
+  const limit = 500;
+  const asString = (value) => {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || value === null) {
+      return String(value);
+    }
+    if (value === undefined) {
+      return "undefined";
+    }
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  };
+  const enqueue = (entry) => {
+    queue.push({
+      ...entry,
+      timestamp: Date.now(),
+    });
+    if (queue.length > limit) {
+      queue.splice(0, queue.length - limit);
+    }
+  };
+
+  globalScope.addEventListener("error", (event) => {
+    enqueue({
+      kind: "page-error",
+      message:
+        typeof event.message === "string" && event.message.length > 0
+          ? event.message
+          : event.error?.message || "Uncaught exception",
+      stack: typeof event.error?.stack === "string" ? event.error.stack : undefined,
+    });
+  });
+
+  globalScope.addEventListener("unhandledrejection", (event) => {
+    const reason = event.reason;
+    enqueue({
+      kind: "page-error",
+      message:
+        typeof reason?.message === "string" && reason.message.length > 0
+          ? reason.message
+          : asString(reason),
+      stack: typeof reason?.stack === "string" ? reason.stack : undefined,
+    });
+  });
+
+  globalScope[key] = {
+    installed: true,
+    drain() {
+      return queue.splice(0, queue.length);
+    },
+  };
+})();`;
 var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
   capabilities = PLAYWRIGHT_BROWSER_CORE_CAPABILITIES;
   browser;
@@ -3760,6 +3987,7 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     flushPendingPageTasks: (sessionRef) => this.flushPendingPageTasks(sessionRef),
     flushDomUpdateTask: (controller) => this.flushDomUpdateTask(controller),
     getMainFrameDocumentRef: (controller) => controller.mainFrameRef === void 0 ? void 0 : this.frames.get(controller.mainFrameRef)?.currentDocument.documentRef,
+    isCurrentMainFrameBootstrapSettled: (controller) => controller.mainFrameRef !== void 0 && this.frames.get(controller.mainFrameRef)?.currentDocument.domContentLoadedAt !== void 0,
     throwBackgroundError: (controller) => this.throwBackgroundError(controller)
   });
   pageCounter = 0;
@@ -4172,11 +4400,15 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     });
     await this.flushPendingPageTasks(controller.sessionRef);
     const mainFrame = this.requireMainFrame(controller);
+    const events = mergeDistinctStepEvents([
+      ...this.drainQueuedEvents(controller.pageRef),
+      ...await this.drainInstrumentedRuntimeEvents(controller)
+    ]);
     return this.createStepResult(controller.sessionRef, controller.pageRef, startedAt, {
       frameRef: mainFrame.frameRef,
       documentRef: mainFrame.currentDocument.documentRef,
       documentEpoch: mainFrame.currentDocument.documentEpoch,
-      events: this.drainQueuedEvents(controller.pageRef),
+      events,
       data: hit
     });
   }
@@ -4196,11 +4428,15 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     await this.flushPendingPageTasks(controller.sessionRef);
     await this.flushDomUpdateTask(controller);
     const mainFrame = this.requireMainFrame(controller);
+    const events = mergeDistinctStepEvents([
+      ...this.drainQueuedEvents(controller.pageRef),
+      ...await this.drainInstrumentedRuntimeEvents(controller)
+    ]);
     return this.createStepResult(controller.sessionRef, controller.pageRef, startedAt, {
       frameRef: mainFrame.frameRef,
       documentRef: mainFrame.currentDocument.documentRef,
       documentEpoch: mainFrame.currentDocument.documentEpoch,
-      events: this.drainQueuedEvents(controller.pageRef),
+      events,
       data: void 0
     });
   }
@@ -4212,11 +4448,15 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     });
     await this.flushPendingPageTasks(controller.sessionRef);
     const mainFrame = this.requireMainFrame(controller);
+    const events = mergeDistinctStepEvents([
+      ...this.drainQueuedEvents(controller.pageRef),
+      ...await this.drainInstrumentedRuntimeEvents(controller)
+    ]);
     return this.createStepResult(controller.sessionRef, controller.pageRef, startedAt, {
       frameRef: mainFrame.frameRef,
       documentRef: mainFrame.currentDocument.documentRef,
       documentEpoch: mainFrame.currentDocument.documentEpoch,
-      events: this.drainQueuedEvents(controller.pageRef),
+      events,
       data: void 0
     });
   }
@@ -4226,11 +4466,15 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     await controller.page.keyboard.type(input.text);
     await this.flushPendingPageTasks(controller.sessionRef);
     const mainFrame = this.requireMainFrame(controller);
+    const events = mergeDistinctStepEvents([
+      ...this.drainQueuedEvents(controller.pageRef),
+      ...await this.drainInstrumentedRuntimeEvents(controller)
+    ]);
     return this.createStepResult(controller.sessionRef, controller.pageRef, startedAt, {
       frameRef: mainFrame.frameRef,
       documentRef: mainFrame.currentDocument.documentRef,
       documentEpoch: mainFrame.currentDocument.documentEpoch,
-      events: this.drainQueuedEvents(controller.pageRef),
+      events,
       data: void 0
     });
   }
@@ -4368,6 +4612,13 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     }
     return infos;
   }
+  async drainEvents(input) {
+    const controller = this.requirePage(input.pageRef);
+    return mergeDistinctStepEvents([
+      ...this.drainQueuedEvents(input.pageRef),
+      ...await this.drainInstrumentedRuntimeEvents(controller)
+    ]);
+  }
   async listFrames(input) {
     const controller = this.requirePage(input.pageRef);
     await this.flushDomUpdateTask(controller);
@@ -4419,6 +4670,12 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       (contentDocIndex) => resolveCapturedContentDocumentRef(controller.framesByCdpId, captured, contentDocIndex)
     );
   }
+  async getActionBoundarySnapshot(input) {
+    const controller = this.requirePage(input.pageRef);
+    await this.flushPendingPageTasks(controller.sessionRef);
+    await this.flushDomUpdateTask(controller);
+    return this.actionSettler.captureSnapshot(controller);
+  }
   async waitForVisualStability(input) {
     const controller = this.requirePage(input.pageRef);
     await this.flushDomUpdateTask(controller);
@@ -4429,6 +4686,21 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     });
     await this.flushDomUpdateTask(controller);
   }
+  async waitForPostLoadQuiet(input) {
+    const controller = this.requirePage(input.pageRef);
+    await this.flushPendingPageTasks(controller.sessionRef);
+    await this.actionSettler.waitForPostLoadQuiet({
+      controller,
+      timeoutMs: clampPlaywrightActionSettleTimeout(input.timeoutMs),
+      ...input.quietMs === void 0 ? {} : { quietMs: input.quietMs },
+      ...input.captureWindowMs === void 0 ? {} : { captureWindowMs: input.captureWindowMs },
+      ...input.signal === void 0 ? {} : { signal: input.signal }
+    });
+    await this.flushPendingPageTasks(controller.sessionRef);
+    if (controller.lifecycleState !== "closed") {
+      await this.flushDomUpdateTask(controller);
+    }
+  }
   async readText(input) {
     const document = this.requireDocument(input.documentRef);
     const controller = this.requirePage(document.pageRef);
@@ -4950,9 +5222,11 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     session.activePageRef = pageRef;
     await cdp.send("Page.enable", { enableFileChooserOpenedEvent: true });
     await cdp.send("Network.enable");
+    await cdp.send("Runtime.enable");
     await cdp.send("DOM.enable", { includeWhitespace: "none" });
     await cdp.send("DOMStorage.enable");
     await cdp.send("DOM.getDocument", { depth: 0 });
+    await this.installRuntimeEventRecorder(page);
     await this.actionSettler.installTracker(controller);
     cdp.on(
       "Page.frameAttached",
@@ -5028,9 +5302,19 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       "DOM.documentUpdated",
       () => this.runControllerEvent(controller, () => this.handleDocumentUpdated(controller))
     );
-    page.on(
-      "console",
-      (message) => this.runControllerEvent(controller, () => this.handleConsole(controller, message))
+    cdp.on(
+      "Runtime.consoleAPICalled",
+      (payload) => this.runControllerEvent(
+        controller,
+        () => this.handleRuntimeConsole(controller, payload)
+      )
+    );
+    cdp.on(
+      "Runtime.exceptionThrown",
+      (payload) => this.runControllerEvent(
+        controller,
+        () => this.handleRuntimeException(controller, payload)
+      )
     );
     page.on(
       "popup",
@@ -5057,10 +5341,6 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       "download",
       (download) => this.runControllerEvent(controller, () => this.handleDownload(controller, download))
     );
-    page.on(
-      "pageerror",
-      (error) => this.runControllerEvent(controller, () => this.handlePageError(controller, error))
-    );
     page.on(
       "request",
       (request) => this.runControllerEvent(controller, () => this.handlePlaywrightRequest(controller, request))
@@ -5072,6 +5352,10 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
         () => this.handlePlaywrightResponse(controller, response)
       )
     );
+    page.on(
+      "domcontentloaded",
+      () => this.runControllerEvent(controller, () => this.handlePageDomContentLoaded(controller))
+    );
     page.on("close", () => this.handleUnexpectedPageClose(controller));
     const frameTree = await cdp.send("Page.getFrameTree");
     this.syncFrameTree(controller, frameTree.frameTree);
@@ -5124,6 +5408,7 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       documentRef,
       documentEpoch: createDocumentEpoch(0),
       url: "about:blank",
+      domContentLoadedAt: void 0,
       parentDocumentRef: parent?.currentDocument.documentRef,
       nodeRefsByBackendNodeId: /* @__PURE__ */ new Map(),
       backendNodeIdsByNodeRef: /* @__PURE__ */ new Map(),
@@ -5182,6 +5467,7 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       documentRef: nextDocumentRef,
       documentEpoch: createDocumentEpoch(0),
       url: combineFrameUrl(frame.url, frame.urlFragment),
+      domContentLoadedAt: void 0,
       parentDocumentRef: parent?.currentDocument.documentRef,
       nodeRefsByBackendNodeId: /* @__PURE__ */ new Map(),
       backendNodeIdsByNodeRef: /* @__PURE__ */ new Map(),
@@ -5211,6 +5497,13 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
   handleDocumentUpdated(controller) {
     this.queueDocumentReconciliation(controller);
   }
+  handlePageDomContentLoaded(controller) {
+    const mainFrame = controller.mainFrameRef === void 0 ? void 0 : this.frames.get(controller.mainFrameRef);
+    if (mainFrame === void 0) {
+      return;
+    }
+    mainFrame.currentDocument.domContentLoadedAt = Date.now();
+  }
   syncFrameTree(controller, tree) {
     const visit = (node, parentFrameRef) => {
       const existing = controller.framesByCdpId.get(node.frame.id);
@@ -5224,6 +5517,7 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
           documentRef,
           documentEpoch: createDocumentEpoch(0),
           url: combineFrameUrl(node.frame.url, node.frame.urlFragment),
+          domContentLoadedAt: void 0,
           parentDocumentRef: parentFrameRef === void 0 ? void 0 : this.requireFrame(parentFrameRef).currentDocument.documentRef,
           nodeRefsByBackendNodeId: /* @__PURE__ */ new Map(),
           backendNodeIdsByNodeRef: /* @__PURE__ */ new Map(),
@@ -5282,19 +5576,20 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       }
     }
   }
-  handleConsole(controller, message) {
+  handleRuntimeConsole(controller, payload) {
+    const callFrame = payload.stackTrace?.callFrames?.[0];
     this.queueEvent(
       controller.pageRef,
       this.createEvent({
         kind: "console",
         sessionRef: controller.sessionRef,
         pageRef: controller.pageRef,
-        level: normalizeConsoleLevel(message.type()),
-        text: message.text(),
+        level: normalizeRuntimeConsoleLevel(payload.type),
+        text: formatRuntimeConsoleText(payload),
         location: {
-          url: message.location().url,
-          lineNumber: message.location().lineNumber,
-          columnNumber: message.location().columnNumber
+          url: callFrame?.url ?? "",
+          lineNumber: callFrame?.lineNumber ?? 0,
+          columnNumber: callFrame?.columnNumber ?? 0
         }
       })
     );
@@ -5375,15 +5670,18 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       })
     );
   }
-  handlePageError(controller, error) {
+  handleRuntimeException(controller, payload) {
+    const details = payload.exceptionDetails;
+    const message = formatRuntimeExceptionMessage(details);
+    const stack = formatRuntimeExceptionStack(details);
     this.queueEvent(
       controller.pageRef,
       this.createEvent({
         kind: "page-error",
         sessionRef: controller.sessionRef,
         pageRef: controller.pageRef,
-        message: error.message,
-        ...error.stack === void 0 ? {} : { stack: error.stack }
+        message,
+        ...stack === void 0 ? {} : { stack }
       })
     );
   }
@@ -6105,10 +6403,11 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     }
   }
   createEvent(value) {
+    const { timestamp, ...event } = value;
     return {
-      ...value,
+      ...event,
       eventId: `event:${++this.eventCounter}`,
-      timestamp: Date.now()
+      timestamp: timestamp ?? Date.now()
     };
   }
   queueEvent(pageRef, event) {
@@ -6118,6 +6417,37 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
     }
     controller.queuedEvents.push(event);
   }
+  async installRuntimeEventRecorder(page) {
+    await page.addInitScript({
+      content: PLAYWRIGHT_RUNTIME_EVENT_RECORDER_SOURCE
+    });
+    await page.evaluate(PLAYWRIGHT_RUNTIME_EVENT_RECORDER_SOURCE).catch(() => void 0);
+  }
+  async drainInstrumentedRuntimeEvents(controller) {
+    const recorded = await Promise.all(
+      controller.page.frames().map(async (frame) => {
+        const events = await frame.evaluate(() => {
+          const recorder = globalThis.__opensteerRuntimeEventRecorder;
+          return recorder?.drain?.() ?? [];
+        }).catch(() => []);
+        return events;
+      })
+    );
+    return mergeDistinctStepEvents(
+      recorded.flatMap(
+        (events) => events.map(
+          (event) => this.createEvent({
+            kind: "page-error",
+            sessionRef: controller.sessionRef,
+            pageRef: controller.pageRef,
+            message: event.message ?? "Uncaught exception",
+            ...event.stack === void 0 ? {} : { stack: event.stack },
+            timestamp: event.timestamp
+          })
+        )
+      )
+    );
+  }
   drainQueuedEvents(pageRef) {
     const controller = this.requirePage(pageRef);
     const events = controller.queuedEvents.splice(0, controller.queuedEvents.length);
@@ -6364,6 +6694,104 @@ function withTimeout(promise, timeoutMs) {
     })
   ]);
 }
+function formatRuntimeConsoleText(payload) {
+  const parts = (payload.args ?? []).map((arg) => formatRuntimeRemoteObject(arg)).filter((value) => value.length > 0);
+  if (parts.length > 0) {
+    return parts.join(" ");
+  }
+  return payload.type?.trim() || "console";
+}
+function normalizeRuntimeConsoleLevel(value) {
+  switch (value) {
+    case "warning":
+    case "debug":
+    case "info":
+    case "error":
+    case "trace":
+      return normalizeConsoleLevel(value);
+    default:
+      return "log";
+  }
+}
+function formatRuntimeExceptionMessage(details) {
+  const description = details?.exception?.description?.trim();
+  if (description) {
+    const firstLine = description.split("\n")[0]?.trim() ?? "";
+    if (firstLine.startsWith("Error: ")) {
+      return firstLine.slice("Error: ".length);
+    }
+    return firstLine || description;
+  }
+  const value = details?.exception?.value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim();
+  }
+  return details?.text?.trim() || "Uncaught exception";
+}
+function formatRuntimeExceptionStack(details) {
+  const description = details?.exception?.description?.trim();
+  if (description && description.includes("\n")) {
+    return description;
+  }
+  const frames = details?.stackTrace?.callFrames;
+  if (!frames || frames.length === 0) {
+    return void 0;
+  }
+  return frames.map((frame) => {
+    const url = frame.url ?? "<anonymous>";
+    const lineNumber = frame.lineNumber ?? 0;
+    const columnNumber = frame.columnNumber ?? 0;
+    return `    at ${url}:${lineNumber}:${columnNumber}`;
+  }).join("\n");
+}
+function formatRuntimeRemoteObject(object) {
+  if (object.unserializableValue !== void 0) {
+    return object.unserializableValue;
+  }
+  if (object.value !== void 0) {
+    return typeof object.value === "string" ? object.value : JSON.stringify(object.value);
+  }
+  if (object.description !== void 0 && object.description.length > 0) {
+    return object.description;
+  }
+  const previewParts = object.preview?.properties?.map((property) => {
+    if (!property.name) {
+      return "";
+    }
+    return property.value === void 0 ? property.name : `${property.name}: ${property.value}`;
+  }).filter((value) => value.length > 0) ?? [];
+  return previewParts.join(", ");
+}
+function mergeDistinctStepEvents(events) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const event of events) {
+    const fingerprint = stepEventFingerprint(event);
+    if (seen.has(fingerprint)) {
+      continue;
+    }
+    seen.add(fingerprint);
+    merged.push(event);
+  }
+  return merged;
+}
+function stepEventFingerprint(event) {
+  switch (event.kind) {
+    case "console":
+      return [
+        event.kind,
+        event.level,
+        event.text,
+        event.location?.url ?? "",
+        event.location?.lineNumber ?? "",
+        event.location?.columnNumber ?? ""
+      ].join("|");
+    case "page-error":
+      return [event.kind, event.message, event.stack ?? ""].join("|");
+    default:
+      return event.eventId;
+  }
+}
 
 export { PlaywrightBrowserCoreEngine, capturePlaywrightStorageOrigins, connectPlaywrightChromiumBrowser, createPlaywrightBrowserCoreEngine, disconnectPlaywrightChromiumBrowser };
 //# sourceMappingURL=index.js.map