@opensteer/engine-playwright 0.8.1 → 0.8.3

package/dist/index.cjs

@@ -1259,6 +1259,355 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// ../browser-core/src/post-load-tracker.ts
+var DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS = 400;
+var DEFAULT_ACTION_BOUNDARY_POLL_INTERVAL_MS = 100;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readNonNegativeNumber(value) {
+  const parsed = readFiniteNumber(value);
+  return parsed === void 0 || parsed < 0 ? 0 : parsed;
+}
+function normalizePostLoadTrackerState(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  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 || 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
+  };
+}
+function buildPostLoadTrackerInstallScript() {
+  return `(() => {
+    const globalObject = globalThis;
+    if (globalObject.__opensteerActionBoundaryTrackerInstalled) {
+      return true;
+    }
+
+    const tracker = {
+      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,
+    };
+    globalObject.__opensteerActionBoundaryTrackerInstalled = true;
+    globalObject.__opensteerActionBoundaryTracker = tracker;
+
+    const markMutation = () => {
+      tracker.lastMutationAt = performance.now();
+      tracker.readyState = document.readyState;
+    };
+    const markNetwork = () => {
+      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;
+      if (!(target instanceof Node)) {
+        return;
+      }
+      const observer = new MutationObserver(markMutation);
+      observer.observe(target, {
+        subtree: true,
+        childList: true,
+        characterData: true,
+        attributes: true,
+      });
+      markMutation();
+    };
+
+    if (document.documentElement) {
+      startObserver();
+    } else {
+      document.addEventListener("DOMContentLoaded", startObserver, { once: true });
+    }
+
+    document.addEventListener("readystatechange", markMutation);
+    addEventListener("load", markMutation, { once: true });
+
+    if (typeof globalObject.fetch === "function") {
+      const nativeFetch = globalObject.fetch.bind(globalObject);
+      globalObject.fetch = (...args) => {
+        const tracked = tracker.collecting === true;
+        tracker.pendingFetches += 1;
+        if (tracked) {
+          tracker.trackedPendingFetches += 1;
+          markTrackedNetwork();
+        } else {
+          markNetwork();
+        }
+        return nativeFetch(...args)
+          .finally(() => {
+            tracker.pendingFetches = Math.max(0, tracker.pendingFetches - 1);
+            if (tracked) {
+              tracker.trackedPendingFetches = Math.max(0, tracker.trackedPendingFetches - 1);
+              markTrackedNetwork();
+            } else {
+              markNetwork();
+            }
+          });
+      };
+    }
+
+    if (typeof globalObject.XMLHttpRequest === "function") {
+      const NativeXMLHttpRequest = globalObject.XMLHttpRequest;
+      const nativeSend = NativeXMLHttpRequest.prototype.send;
+      NativeXMLHttpRequest.prototype.send = function(...args) {
+        const tracked = tracker.collecting === true;
+        tracker.pendingXhrs += 1;
+        if (tracked) {
+          tracker.trackedPendingXhrs += 1;
+          markTrackedNetwork();
+        } else {
+          markNetwork();
+        }
+        const finalize = () => {
+          this.removeEventListener("loadend", finalize);
+          tracker.pendingXhrs = Math.max(0, tracker.pendingXhrs - 1);
+          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;
+    if (!tracker) {
+      return null;
+    }
+
+    return {
+      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;
+  }
+  if (tracker.readyState !== "complete") {
+    return false;
+  }
+  if (tracker.trackedPendingFetches > 0 || tracker.trackedPendingXhrs > 0) {
+    return false;
+  }
+  const lastActivityAt = Math.max(
+    tracker.installedAt,
+    tracker.lastMutationAt,
+    tracker.lastTrackedNetworkActivityAt
+  );
+  return tracker.now - lastActivityAt >= quietWindowMs;
+}
+
+// ../browser-core/src/action-boundary.ts
+var CROSS_DOCUMENT_INTERACTION_TIMEOUT_MS = 3e4;
+var CROSS_DOCUMENT_DETECTION_WINDOW_MS = 500;
+async function waitForActionBoundary(input) {
+  if (input.timeoutMs <= 0) {
+    return {
+      trigger: "dom-action",
+      crossDocument: false,
+      bootstrapSettled: false,
+      timedOutPhase: "bootstrap"
+    };
+  }
+  const deadline = Date.now() + input.timeoutMs;
+  const crossDocumentDetectionDeadline = input.snapshot === void 0 ? void 0 : Math.min(deadline, Date.now() + CROSS_DOCUMENT_DETECTION_WINDOW_MS);
+  const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_ACTION_BOUNDARY_POLL_INTERVAL_MS;
+  let trigger = "dom-action";
+  let crossDocument = false;
+  let sameDocumentAsyncActivity = false;
+  while (Date.now() < deadline) {
+    input.throwBackgroundError();
+    if (input.isPageClosed()) {
+      return {
+        trigger,
+        crossDocument,
+        bootstrapSettled: true
+      };
+    }
+    if (input.signal?.aborted) {
+      if (isTimeoutAbort(input.signal.reason) && Date.now() >= deadline) {
+        return {
+          trigger,
+          crossDocument,
+          bootstrapSettled: false,
+          timedOutPhase: "bootstrap"
+        };
+      }
+      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 (!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 {
+        trigger,
+        crossDocument,
+        bootstrapSettled: true
+      };
+    }
+    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,
+        bootstrapSettled: true
+      };
+    }
+    await delay(Math.min(pollIntervalMs, Math.max(0, deadline - Date.now())));
+  }
+  return {
+    trigger,
+    crossDocument,
+    bootstrapSettled: false,
+    timedOutPhase: "bootstrap"
+  };
+}
+function abortError(signal) {
+  return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+async function delay(ms) {
+  if (ms <= 0) {
+    return;
+  }
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function isTimeoutAbort(reason) {
+  return typeof reason === "object" && reason !== null && "code" in reason && reason.code === "timeout";
+}
+
 // ../protocol/src/computer-use-bridge.ts
 var OPENSTEER_COMPUTER_USE_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@opensteer/computer-use-bridge");
 
@@ -1743,6 +2092,7 @@ function createPlaywrightComputerUseBridge(context) {
       const startedAt = Date.now();
       const actionController = context.resolveController(input.pageRef);
       const action = input.action;
+      let boundary;
       let actionMs = 0;
       let waitMs = 0;
       const actionStartedAt = Date.now();
@@ -1808,7 +2158,12 @@ function createPlaywrightComputerUseBridge(context) {
       await context.flushPendingPageTasks(actionController.sessionRef);
       if (action.type !== "screenshot" && action.type !== "wait") {
         const waitStartedAt = Date.now();
-        await input.policySettle(actionController.pageRef);
+        boundary = await context.settleActionBoundary(actionController, {
+          signal: input.signal,
+          ...input.snapshot === void 0 ? {} : { snapshot: input.snapshot },
+          remainingMs: input.remainingMs,
+          policySettle: input.policySettle
+        });
         waitMs = Date.now() - waitStartedAt;
       } else if (action.type === "wait") {
         waitMs = actionMs;
@@ -1820,7 +2175,11 @@ function createPlaywrightComputerUseBridge(context) {
       let resultController = context.resolveController(resultPageRef);
       if (action.type !== "screenshot" && action.type !== "wait" && resultController.pageRef !== actionController.pageRef) {
         const popupWaitStartedAt = Date.now();
-        await input.policySettle(resultController.pageRef);
+        await context.settleActionBoundary(resultController, {
+          signal: input.signal,
+          remainingMs: input.remainingMs,
+          policySettle: input.policySettle
+        });
         waitMs += Date.now() - popupWaitStartedAt;
         await context.flushPendingPageTasks(actionController.sessionRef);
         resultController = context.resolveController(resultController.pageRef);
@@ -1844,7 +2203,8 @@ function createPlaywrightComputerUseBridge(context) {
           actionMs,
           waitMs,
           totalMs: Date.now() - startedAt
-        }
+        },
+        ...boundary === void 0 ? {} : { boundary }
       };
     }
   };
@@ -2877,10 +3237,12 @@ function createPlaywrightDomActionBridge(context) {
     },
     async finalizeDomAction(pageRef, options) {
       const controller = context.resolveController(pageRef);
-      await context.flushPendingPageTasks(controller.sessionRef);
-      await options.policySettle(pageRef);
-      await context.flushPendingPageTasks(controller.sessionRef);
-      await context.flushDomUpdateTask(controller);
+      return context.settleActionBoundary(controller, {
+        signal: options.signal,
+        ...options.snapshot === void 0 ? {} : { snapshot: options.snapshot },
+        remainingMs: options.remainingMs,
+        policySettle: options.policySettle
+      });
     }
   };
 }
@@ -3148,6 +3510,210 @@ async function releaseObject(controller, objectId) {
   await controller.cdp.send("Runtime.releaseObject", { objectId }).catch(() => void 0);
 }
 
+// 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;
+  }
+  return Math.max(0, Math.min(DEFAULT_PLAYWRIGHT_ACTION_SETTLE_TIMEOUT_MS, timeoutMs));
+}
+function createPlaywrightActionSettler(context) {
+  const installScript = buildPostLoadTrackerInstallScript();
+  const beginExpression = buildPostLoadTrackerBeginExpression();
+  const freezeExpression = buildPostLoadTrackerFreezeExpression();
+  const readExpression = buildPostLoadTrackerReadExpression();
+  async function installTracker(controller) {
+    if (!controller.settleTrackerRegistered) {
+      await controller.page.addInitScript(installScript);
+      controller.settleTrackerRegistered = true;
+    }
+    try {
+      await controller.cdp.send("Runtime.evaluate", {
+        expression: installScript,
+        returnByValue: true,
+        awaitPromise: true
+      });
+    } catch (error) {
+      if (controller.lifecycleState === "closed" || isContextClosedError(error)) {
+        return;
+      }
+      throw normalizePlaywrightError(error, controller.pageRef);
+    }
+  }
+  async function readTrackerState(controller) {
+    try {
+      const evaluated = await controller.cdp.send("Runtime.evaluate", {
+        expression: readExpression,
+        returnByValue: true,
+        awaitPromise: true
+      });
+      return normalizePostLoadTrackerState(evaluated.result?.value);
+    } catch (error) {
+      if (isIgnorableTrackerReadError(error)) {
+        return void 0;
+      }
+      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) {
+      return {
+        trigger: "dom-action",
+        crossDocument: false,
+        bootstrapSettled: false,
+        timedOutPhase: "bootstrap"
+      };
+    }
+    await context.flushPendingPageTasks(controller.sessionRef);
+    let boundary;
+    if (snapshot === void 0) {
+      if (policySettle) {
+        if (signal?.aborted) {
+          throw signal.reason ?? abortError2();
+        }
+        await policySettle(controller.pageRef, "dom-action");
+      }
+      boundary = {
+        trigger: "dom-action",
+        crossDocument: false,
+        bootstrapSettled: true
+      };
+    } else {
+      await installTracker(controller);
+      boundary = await waitForActionBoundary({
+        timeoutMs,
+        ...signal === void 0 ? {} : { signal },
+        snapshot,
+        getCurrentMainFrameDocumentRef: () => context.getMainFrameDocumentRef(controller),
+        getCurrentPageUrl: () => controller.page.url(),
+        isCurrentMainFrameBootstrapSettled: () => context.isCurrentMainFrameBootstrapSettled(controller),
+        readTrackerState: () => readTrackerState(controller),
+        throwBackgroundError: () => context.throwBackgroundError(controller),
+        isPageClosed: () => controller.lifecycleState === "closed"
+      });
+      if (policySettle) {
+        await policySettle(controller.pageRef, boundary.trigger);
+      }
+    }
+    await context.flushPendingPageTasks(controller.sessionRef);
+    if (controller.lifecycleState !== "closed") {
+      await context.flushDomUpdateTask(controller);
+    }
+    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
+  );
+}
+
 // src/storage-capture.ts
 var ACTIVATION_PATH = "/__opensteer_storage_capture__";
 var ACTIVATION_TIMEOUT_MS = 15e3;
@@ -3339,6 +3905,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;
@@ -3354,6 +3985,13 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
   pageByPlaywrightPage = /* @__PURE__ */ new WeakMap();
   pendingPopupOpeners = /* @__PURE__ */ new WeakMap();
   preassignedPopupPageRefs = /* @__PURE__ */ new WeakMap();
+  actionSettler = createPlaywrightActionSettler({
+    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;
   frameCounter = 0;
   documentCounter = 0;
@@ -3409,6 +4047,13 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       resolveController: (pageRef) => this.requirePage(pageRef),
       flushPendingPageTasks: (sessionRef) => this.flushPendingPageTasks(sessionRef),
       flushDomUpdateTask: (controller) => this.flushDomUpdateTask(controller),
+      settleActionBoundary: (controller, options) => this.actionSettler.settle({
+        controller,
+        timeoutMs: clampPlaywrightActionSettleTimeout(options.remainingMs()),
+        ...options.signal === void 0 ? {} : { signal: options.signal },
+        ...options.snapshot === void 0 ? {} : { snapshot: options.snapshot },
+        ...options.policySettle === void 0 ? {} : { policySettle: options.policySettle }
+      }),
       requireMainFrame: (controller) => this.requireMainFrame(controller),
       drainQueuedEvents: (pageRef) => this.drainQueuedEvents(pageRef),
       withModifiers: (page, modifiers, action) => this.withModifiers(page, modifiers, action)
@@ -3420,6 +4065,13 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       resolveController: (pageRef) => this.requirePage(pageRef),
       flushPendingPageTasks: (sessionRef) => this.flushPendingPageTasks(sessionRef),
       flushDomUpdateTask: (controller) => this.flushDomUpdateTask(controller),
+      settleActionBoundary: (controller, options) => this.actionSettler.settle({
+        controller,
+        timeoutMs: clampPlaywrightActionSettleTimeout(options.remainingMs()),
+        ...options.signal === void 0 ? {} : { signal: options.signal },
+        ...options.snapshot === void 0 ? {} : { snapshot: options.snapshot },
+        ...options.policySettle === void 0 ? {} : { policySettle: options.policySettle }
+      }),
       locateBackendNode: (document, backendNodeId) => createNodeLocator(
         document.documentRef,
         document.documentEpoch,
@@ -3750,11 +4402,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
     });
   }
@@ -3774,11 +4430,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
     });
   }
@@ -3790,11 +4450,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
     });
   }
@@ -3804,11 +4468,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
     });
   }
@@ -3946,6 +4614,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);
@@ -3997,6 +4672,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);
@@ -4007,6 +4688,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);
@@ -4514,6 +5210,7 @@ var PlaywrightBrowserCoreEngine = class _PlaywrightBrowserCoreEngine {
       backgroundTasks: /* @__PURE__ */ new Set(),
       domUpdateTask: void 0,
       backgroundError: void 0,
+      settleTrackerRegistered: false,
       openerPageRef: void 0,
       mainFrameRef: void 0,
       lifecycleState: "open",
@@ -4527,9 +5224,12 @@ 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",
       (payload) => this.runControllerEvent(
@@ -4604,9 +5304,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",
@@ -4633,10 +5343,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))
@@ -4648,6 +5354,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);
@@ -4700,6 +5410,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(),
@@ -4758,6 +5469,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(),
@@ -4787,6 +5499,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);
@@ -4800,6 +5519,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(),
@@ -4858,19 +5578,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
         }
       })
     );
@@ -4951,15 +5672,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 }
       })
     );
   }
@@ -5681,10 +6405,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) {
@@ -5694,6 +6419,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);
@@ -5940,6 +6696,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;
+  }
+}
 
 exports.PlaywrightBrowserCoreEngine = PlaywrightBrowserCoreEngine;
 exports.capturePlaywrightStorageOrigins = capturePlaywrightStorageOrigins;