@opensteer/engine-abp 0.8.2 → 0.8.4

package/dist/index.js

@@ -1252,6 +1252,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");
 
@@ -1886,7 +2235,7 @@ async function waitForReady(baseUrl) {
       }
     } catch {
     }
-    await delay(200);
+    await delay2(200);
   }
   throw createBrowserCoreError("timeout", `ABP did not become ready within 30000ms at ${baseUrl}`);
 }
@@ -1903,19 +2252,19 @@ async function waitForDevToolsPort(userDataDir) {
       }
     } catch {
     }
-    await delay(200);
+    await delay2(200);
   }
   throw createBrowserCoreError(
     "timeout",
     `CDP port file was not written to ${userDataDir} within 30000ms`
   );
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/action-events.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function readBoolean(value) {
@@ -1928,7 +2277,7 @@ function readString(value) {
   return typeof value === "string" ? value : void 0;
 }
 function parseSelectPopupItem(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return void 0;
   }
   const index = readInteger(value.index);
@@ -1987,225 +2336,22 @@ function normalizeSelectChooserEventData(data) {
 }
 
 // src/action-settle.ts
-var DEFAULT_ABP_ACTION_SETTLE_TIMEOUT_MS = 5e3;
-var POST_ACTION_SETTLE_QUIET_WINDOW_MS = 400;
-var POST_ACTION_SETTLE_POLL_INTERVAL_MS = 100;
+var DEFAULT_ABP_ACTION_SETTLE_TIMEOUT_MS = CROSS_DOCUMENT_INTERACTION_TIMEOUT_MS;
+var DEFAULT_ABP_POST_LOAD_CAPTURE_WINDOW_MS = 1e3;
 function clampAbpActionSettleTimeout(timeoutMs) {
   if (timeoutMs === void 0) {
     return DEFAULT_ABP_ACTION_SETTLE_TIMEOUT_MS;
   }
   return Math.max(0, Math.min(DEFAULT_ABP_ACTION_SETTLE_TIMEOUT_MS, timeoutMs));
 }
-function isRecord2(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 normalizeAbpSettleTrackerState(value) {
-  if (!isRecord2(value)) {
-    return void 0;
-  }
-  const installedAt = readFiniteNumber(value.installedAt);
-  const lastMutationAt = readFiniteNumber(value.lastMutationAt);
-  const lastNetworkActivityAt = readFiniteNumber(value.lastNetworkActivityAt);
-  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) {
-    return void 0;
-  }
-  return {
-    installedAt,
-    lastMutationAt,
-    lastNetworkActivityAt,
-    now,
-    pendingFetches: readNonNegativeNumber(value.pendingFetches),
-    pendingTimeouts: readNonNegativeNumber(value.pendingTimeouts),
-    pendingXhrs: readNonNegativeNumber(value.pendingXhrs),
-    readyState
-  };
-}
-function buildAbpSettleTrackerInstallScript() {
-  return `(() => {
-    const globalObject = globalThis;
-    if (globalObject.__opensteerAbpSettleTrackerInstalled) {
-      return true;
-    }
-
-    const tracker = {
-      installedAt: performance.now(),
-      lastMutationAt: performance.now(),
-      lastNetworkActivityAt: performance.now(),
-      pendingFetches: 0,
-      pendingTimeouts: 0,
-      pendingXhrs: 0,
-      readyState: document.readyState,
-      timeoutIds: new Set(),
-    };
-    globalObject.__opensteerAbpSettleTrackerInstalled = true;
-    globalObject.__opensteerAbpSettleTracker = tracker;
-
-    const markMutation = () => {
-      tracker.lastMutationAt = performance.now();
-      tracker.readyState = document.readyState;
-    };
-    const markNetwork = () => {
-      tracker.lastNetworkActivityAt = performance.now();
-      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 });
-
-    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) => {
-        tracker.pendingFetches += 1;
-        markNetwork();
-        return nativeFetch(...args)
-          .finally(() => {
-            tracker.pendingFetches = Math.max(0, tracker.pendingFetches - 1);
-            markNetwork();
-          });
-      };
-    }
-
-    if (typeof globalObject.XMLHttpRequest === "function") {
-      const NativeXMLHttpRequest = globalObject.XMLHttpRequest;
-      const nativeSend = NativeXMLHttpRequest.prototype.send;
-      NativeXMLHttpRequest.prototype.send = function(...args) {
-        tracker.pendingXhrs += 1;
-        markNetwork();
-        const finalize = () => {
-          this.removeEventListener("loadend", finalize);
-          tracker.pendingXhrs = Math.max(0, tracker.pendingXhrs - 1);
-          markNetwork();
-        };
-        this.addEventListener("loadend", finalize, { once: true });
-        return nativeSend.apply(this, args);
-      };
-    }
-
-    return true;
-  })()`;
-}
-function buildAbpSettleTrackerReadExpression() {
-  return `(() => {
-    const tracker = globalThis.__opensteerAbpSettleTracker;
-    if (!tracker) {
-      return null;
-    }
-
-    return {
-      installedAt: Number(tracker.installedAt ?? 0),
-      lastMutationAt: Number(tracker.lastMutationAt ?? 0),
-      lastNetworkActivityAt: Number(tracker.lastNetworkActivityAt ?? 0),
-      now: Number(performance.now()),
-      pendingFetches: Number(tracker.pendingFetches ?? 0),
-      pendingTimeouts: Number(tracker.pendingTimeouts ?? 0),
-      pendingXhrs: Number(tracker.pendingXhrs ?? 0),
-      readyState: String(document.readyState),
-    };
-  })()`;
-}
-function trackerStateIsSettled(tracker) {
-  if (!tracker) {
-    return false;
-  }
-  if (tracker.readyState !== "complete") {
-    return false;
-  }
-  if (tracker.pendingFetches > 0 || tracker.pendingTimeouts > 0 || tracker.pendingXhrs > 0) {
-    return false;
-  }
-  const lastActivityAt = Math.max(
-    tracker.installedAt,
-    tracker.lastMutationAt,
-    tracker.lastNetworkActivityAt
-  );
-  return tracker.now - lastActivityAt >= POST_ACTION_SETTLE_QUIET_WINDOW_MS;
-}
-function abortError(signal) {
+function abortError2(signal) {
   return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
 }
-async function delay2(ms, signal) {
-  if (ms <= 0) {
-    return;
-  }
-  if (signal?.aborted) {
-    throw abortError(signal);
-  }
-  await new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timeoutId);
-      signal?.removeEventListener("abort", onAbort);
-      reject(abortError(signal));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
 function createAbpActionSettler(context) {
-  const installScript = buildAbpSettleTrackerInstallScript();
-  const readExpression = buildAbpSettleTrackerReadExpression();
+  const installScript = buildPostLoadTrackerInstallScript();
+  const beginExpression = buildPostLoadTrackerBeginExpression();
+  const freezeExpression = buildPostLoadTrackerFreezeExpression();
+  const readExpression = buildPostLoadTrackerReadExpression();
   async function installTracker(controller) {
     if (!controller.settleTrackerRegistered) {
       await controller.cdp.send("Page.addScriptToEvaluateOnNewDocument", {
@@ -2220,47 +2366,130 @@ function createAbpActionSettler(context) {
     });
   }
   async function readTrackerState(controller) {
-    const evaluated = await controller.cdp.send("Runtime.evaluate", {
-      expression: readExpression,
+    try {
+      const evaluated = await controller.cdp.send("Runtime.evaluate", {
+        expression: readExpression,
+        returnByValue: true,
+        awaitPromise: true
+      });
+      return normalizePostLoadTrackerState(evaluated.result?.value);
+    } catch (error) {
+      if (context.isPageClosedError(error)) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async function beginTrackerObservation(controller) {
+    await installTracker(controller);
+    await controller.cdp.send("Runtime.evaluate", {
+      expression: beginExpression,
       returnByValue: true,
       awaitPromise: true
     });
-    return normalizeAbpSettleTrackerState(evaluated.result?.value);
   }
-  async function settle(options) {
-    const { controller, timeoutMs, signal, policySettle } = options;
+  async function freezeTrackerObservation(controller) {
+    await controller.cdp.send("Runtime.evaluate", {
+      expression: freezeExpression,
+      returnByValue: true,
+      awaitPromise: true
+    });
+  }
+  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,
+      ...controller.mainFrameRef === void 0 ? {} : {
+        url: controller.framesByCdpId.get(controller.mainFrameRef)?.currentDocument.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_ABP_POST_LOAD_CAPTURE_WINDOW_MS, timeoutMs)
+    );
     const deadline = Date.now() + timeoutMs;
+    await installTracker(controller);
+    if (captureWindowMs > 0) {
+      await delayWithSignal(captureWindowMs, signal, deadline);
+    }
+    await freezeTrackerObservation(controller);
+    while (Date.now() < deadline) {
+      if (signal?.aborted) {
+        throw abortError2(signal);
+      }
+      context.throwBackgroundError(controller);
+      if (controller.lifecycleState === "closed") {
+        return;
+      }
+      if (postLoadTrackerIsSettled(await readTrackerState(controller), quietMs)) {
+        return;
+      }
+      await delayWithSignal(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"
+      };
+    }
     const wasPaused = await context.syncExecutionPaused(controller);
+    let boundary = {
+      trigger: "dom-action",
+      crossDocument: false,
+      bootstrapSettled: false,
+      timedOutPhase: "bootstrap"
+    };
     if (wasPaused) {
       await context.setExecutionPaused(controller, false);
     }
     try {
-      await installTracker(controller);
-      if (policySettle) {
-        if (signal?.aborted) {
-          throw abortError(signal);
-        }
-        await policySettle(controller.pageRef, signal);
-      }
-      while (Date.now() < deadline) {
-        context.throwBackgroundError(controller);
-        if (controller.lifecycleState === "closed") {
-          return;
-        }
-        if (signal?.aborted) {
-          throw abortError(signal);
+      if (snapshot === void 0) {
+        if (policySettle) {
+          if (signal?.aborted) {
+            throw abortError2(signal);
+          }
+          await policySettle(controller.pageRef, "dom-action");
         }
-        const tracker = await readTrackerState(controller).catch(() => void 0);
-        if (trackerStateIsSettled(tracker)) {
-          break;
+        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.mainFrameRef === void 0 ? void 0 : controller.framesByCdpId.get(controller.mainFrameRef)?.currentDocument.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 delay2(
-          Math.min(POST_ACTION_SETTLE_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())),
-          signal
-        );
       }
     } finally {
       if (wasPaused && controller.lifecycleState !== "closed") {
@@ -2270,7 +2499,6 @@ function createAbpActionSettler(context) {
           if (!context.isPageClosedError(error)) {
             throw error;
           }
-          return;
         }
       }
       if (controller.lifecycleState !== "closed") {
@@ -2283,12 +2511,36 @@ function createAbpActionSettler(context) {
         }
       }
     }
+    return boundary;
   }
   return {
+    captureSnapshot,
     installTracker,
+    waitForPostLoadQuiet,
     settle
   };
 }
+async function delayWithSignal(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 abortError2(signal);
+  }
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, effectiveDelay);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(abortError2(signal));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 
 // src/rest-client.ts
 function isRecord3(value) {
@@ -2709,6 +2961,7 @@ function createAbpComputerUseBridge(context) {
       });
       let response;
       let dialogEvents = [];
+      let boundary;
       switch (action.type) {
         case "click": {
           const executed = await context.executeInputAction(
@@ -2839,8 +3092,9 @@ function createAbpComputerUseBridge(context) {
       const resultController = context.resolveController(resultPageRef);
       let displayResponse = response;
       if (action.type !== "screenshot") {
-        await context.settleActionBoundary(resultController, {
+        boundary = await context.settleActionBoundary(resultController, {
           timeoutMs: clampAbpActionSettleTimeout(remainingMs),
+          ...resultController.pageRef === controller.pageRef && input.snapshot !== void 0 ? { snapshot: input.snapshot } : {},
           signal: input.signal,
           policySettle: input.policySettle
         });
@@ -2871,7 +3125,8 @@ function createAbpComputerUseBridge(context) {
           ...dialogEvents,
           ...popupQueuedEvents
         ],
-        timing: timingFromResponse(response, Date.now() - startedAt)
+        timing: timingFromResponse(response, Date.now() - startedAt),
+        ...boundary === void 0 ? {} : { boundary }
       };
     }
   };
@@ -3547,8 +3802,9 @@ function createAbpDomActionBridge(context) {
     },
     async finalizeDomAction(pageRef, options) {
       const controller = context.resolveController(pageRef);
-      await context.settleActionBoundary(controller, {
+      const boundary = await context.settleActionBoundary(controller, {
         timeoutMs: clampAbpActionSettleTimeout(options.remainingMs()),
+        ...options.snapshot === void 0 ? {} : { snapshot: options.snapshot },
         signal: options.signal,
         policySettle: options.policySettle
       });
@@ -3558,6 +3814,7 @@ function createAbpDomActionBridge(context) {
           details: { pageRef }
         });
       }
+      return boundary;
     }
   };
 }
@@ -4197,6 +4454,8 @@ var AbpBrowserCoreEngine = class _AbpBrowserCoreEngine {
     syncExecutionPaused: (controller) => this.syncControllerExecutionPaused(controller),
     setExecutionPaused: (controller, paused) => this.setControllerExecutionPaused(controller, paused),
     flushDomUpdateTask: (controller) => this.flushDomUpdateTask(controller),
+    getMainFrameDocumentRef: (controller) => controller.mainFrameRef === void 0 ? void 0 : this.frames.get(controller.mainFrameRef)?.currentDocument.documentRef,
+    isCurrentMainFrameBootstrapSettled: () => true,
     throwBackgroundError: (controller) => this.throwBackgroundError(controller),
     isPageClosedError: isAbpPageClosedError
   });
@@ -4959,6 +5218,9 @@ var AbpBrowserCoreEngine = class _AbpBrowserCoreEngine {
       )
     );
   }
+  async drainEvents(input) {
+    return this.drainQueuedEvents(input.pageRef);
+  }
   async listFrames(input) {
     const controller = this.requirePage(input.pageRef);
     await this.flushDomUpdateTask(controller);
@@ -5010,6 +5272,11 @@ var AbpBrowserCoreEngine = class _AbpBrowserCoreEngine {
       (contentDocumentIndex) => resolveCapturedContentDocumentRef(controller.framesByCdpId, captured, contentDocumentIndex)
     );
   }
+  async getActionBoundarySnapshot(input) {
+    const controller = this.requirePage(input.pageRef);
+    await this.flushDomUpdateTask(controller);
+    return this.actionSettler.captureSnapshot(controller);
+  }
   async waitForVisualStability(input) {
     const controller = this.requirePage(input.pageRef);
     await this.flushDomUpdateTask(controller);
@@ -5020,6 +5287,20 @@ var AbpBrowserCoreEngine = class _AbpBrowserCoreEngine {
     });
     await this.flushDomUpdateTask(controller);
   }
+  async waitForPostLoadQuiet(input) {
+    const controller = this.requirePage(input.pageRef);
+    await this.flushDomUpdateTask(controller);
+    await this.actionSettler.waitForPostLoadQuiet({
+      controller,
+      timeoutMs: clampAbpActionSettleTimeout(input.timeoutMs),
+      ...input.quietMs === void 0 ? {} : { quietMs: input.quietMs },
+      ...input.captureWindowMs === void 0 ? {} : { captureWindowMs: input.captureWindowMs },
+      ...input.signal === void 0 ? {} : { signal: input.signal }
+    });
+    if (controller.lifecycleState !== "closed") {
+      await this.flushDomUpdateTask(controller);
+    }
+  }
   async readText(input) {
     const document = this.requireDocument(input.documentRef);
     const controller = this.requirePage(document.pageRef);