opensteer 0.4.5 → 0.4.6

package/dist/{chunk-2NKR4JZ6.js → chunk-MGZ3QEYT.js}

@@ -37,15 +37,52 @@ function sanitizeNamespaceSegment(segment) {
 // src/navigation.ts
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_SETTLE_MS = 750;
+var FRAME_EVALUATE_GRACE_MS = 200;
+var STEALTH_WORLD_NAME = "__opensteer_wait__";
+var StealthWaitUnavailableError = class extends Error {
+  constructor(cause) {
+    super("Stealth visual wait requires Chromium CDP support.", { cause });
+    this.name = "StealthWaitUnavailableError";
+  }
+};
+function isStealthWaitUnavailableError(error) {
+  return error instanceof StealthWaitUnavailableError;
+}
+var FRAME_OWNER_VISIBILITY_FUNCTION = `function() {
+    if (!(this instanceof HTMLElement)) return false;
+
+    var rect = this.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) return false;
+    if (
+        rect.bottom <= 0 ||
+        rect.right <= 0 ||
+        rect.top >= window.innerHeight ||
+        rect.left >= window.innerWidth
+    ) {
+        return false;
+    }
+
+    var style = window.getComputedStyle(this);
+    if (
+        style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        Number(style.opacity) === 0
+    ) {
+        return false;
+    }
+
+    return true;
+}`;
 function buildStabilityScript(timeout, settleMs) {
   return `new Promise(function(resolve) {
     var deadline = Date.now() + ${timeout};
-    var timer = null;
     var resolved = false;
+    var timer = null;
     var observers = [];
     var observedShadowRoots = [];
     var fonts = document.fonts;
     var fontsReady = !fonts || fonts.status === 'loaded';
+    var lastRelevantMutationAt = Date.now();
 
     function clearObservers() {
         for (var i = 0; i < observers.length; i++) {
@@ -63,9 +100,87 @@ function buildStabilityScript(timeout, settleMs) {
         resolve();
     }
 
+    function isElementVisiblyIntersectingViewport(element) {
+        if (!(element instanceof Element)) return false;
+
+        var rect = element.getBoundingClientRect();
+        var inViewport =
+            rect.width > 0 &&
+            rect.height > 0 &&
+            rect.bottom > 0 &&
+            rect.right > 0 &&
+            rect.top < window.innerHeight &&
+            rect.left < window.innerWidth;
+
+        if (!inViewport) return false;
+
+        var style = window.getComputedStyle(element);
+        if (style.visibility === 'hidden' || style.display === 'none') {
+            return false;
+        }
+        if (Number(style.opacity) === 0) {
+            return false;
+        }
+
+        return true;
+    }
+
+    function resolveRelevantElement(node) {
+        if (!node) return null;
+        if (node instanceof Element) return node;
+        if (typeof ShadowRoot !== 'undefined' && node instanceof ShadowRoot) {
+            return node.host instanceof Element ? node.host : null;
+        }
+        var parentElement = node.parentElement;
+        return parentElement instanceof Element ? parentElement : null;
+    }
+
+    function isNodeVisiblyRelevant(node) {
+        var element = resolveRelevantElement(node);
+        if (!element) return false;
+        return isElementVisiblyIntersectingViewport(element);
+    }
+
+    function hasRelevantMutation(records) {
+        for (var i = 0; i < records.length; i++) {
+            var record = records[i];
+            if (isNodeVisiblyRelevant(record.target)) return true;
+
+            var addedNodes = record.addedNodes;
+            for (var j = 0; j < addedNodes.length; j++) {
+                if (isNodeVisiblyRelevant(addedNodes[j])) return true;
+            }
+
+            var removedNodes = record.removedNodes;
+            for (var k = 0; k < removedNodes.length; k++) {
+                if (isNodeVisiblyRelevant(removedNodes[k])) return true;
+            }
+        }
+
+        return false;
+    }
+
+    function scheduleCheck() {
+        if (resolved) return;
+        if (timer) clearTimeout(timer);
+
+        var remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            done();
+            return;
+        }
+
+        var checkDelay = Math.min(120, Math.max(16, ${settleMs}));
+        timer = setTimeout(checkNow, checkDelay);
+    }
+
     function observeMutations(target) {
         if (!target) return;
-        var observer = new MutationObserver(function() { settle(); });
+        var observer = new MutationObserver(function(records) {
+            if (!hasRelevantMutation(records)) return;
+            lastRelevantMutationAt = Date.now();
+            scheduleCheck();
+        });
         observer.observe(target, {
             childList: true,
             subtree: true,
@@ -103,18 +218,25 @@ function buildStabilityScript(timeout, settleMs) {
         var images = root.querySelectorAll('img');
         for (var i = 0; i < images.length; i++) {
             var img = images[i];
-            var rect = img.getBoundingClientRect();
-            var inViewport =
-                rect.bottom > 0 &&
-                rect.right > 0 &&
-                rect.top < window.innerHeight &&
-                rect.left < window.innerWidth;
-            if (inViewport && !img.complete) return false;
+            if (!isElementVisiblyIntersectingViewport(img)) continue;
+            if (!img.complete) return false;
         }
         return true;
     }
 
-    function hasRunningFiniteAnimations() {
+    function getAnimationTarget(effect) {
+        if (!effect) return null;
+        var target = effect.target;
+        if (target instanceof Element) return target;
+
+        if (target && target.element instanceof Element) {
+            return target.element;
+        }
+
+        return null;
+    }
+
+    function hasRunningVisibleFiniteAnimations() {
         if (typeof document.getAnimations !== 'function') return false;
         var animations = document.getAnimations();
 
@@ -128,6 +250,9 @@ function buildStabilityScript(timeout, settleMs) {
                 ? timing.endTime
                 : Number.POSITIVE_INFINITY;
             if (Number.isFinite(endTime) && endTime > 0) {
+                var target = getAnimationTarget(effect);
+                if (!target) continue;
+                if (!isElementVisiblyIntersectingViewport(target)) continue;
                 return true;
             }
         }
@@ -138,21 +263,29 @@ function buildStabilityScript(timeout, settleMs) {
     function isVisuallyReady() {
         if (!fontsReady) return false;
         if (!checkViewportImages(document)) return false;
-        if (hasRunningFiniteAnimations()) return false;
+        if (hasRunningVisibleFiniteAnimations()) return false;
         return true;
     }
 
-    function settle() {
-        if (Date.now() > deadline) { done(); return; }
-        if (timer) clearTimeout(timer);
+    function checkNow() {
+        if (Date.now() >= deadline) {
+            done();
+            return;
+        }
+
         observeOpenShadowRoots();
-        timer = setTimeout(function() {
-            if (isVisuallyReady()) {
-                done();
-            } else {
-                settle();
-            }
-        }, ${settleMs});
+
+        if (!isVisuallyReady()) {
+            scheduleCheck();
+            return;
+        }
+
+        if (Date.now() - lastRelevantMutationAt >= ${settleMs}) {
+            done();
+            return;
+        }
+
+        scheduleCheck();
     }
 
     observeMutations(document.documentElement);
@@ -161,67 +294,266 @@ function buildStabilityScript(timeout, settleMs) {
     if (fonts && fonts.ready && typeof fonts.ready.then === 'function') {
         fonts.ready.then(function() {
             fontsReady = true;
-            settle();
+            scheduleCheck();
+        }, function() {
+            fontsReady = true;
+            scheduleCheck();
         });
     }
 
     var safetyTimer = setTimeout(done, ${timeout});
 
-    settle();
+    scheduleCheck();
 })`;
 }
+var StealthCdpRuntime = class _StealthCdpRuntime {
+  constructor(session) {
+    this.session = session;
+  }
+  contextsByFrame = /* @__PURE__ */ new Map();
+  disposed = false;
+  static async create(page) {
+    let session;
+    try {
+      session = await page.context().newCDPSession(page);
+    } catch (error) {
+      throw new StealthWaitUnavailableError(error);
+    }
+    const runtime = new _StealthCdpRuntime(session);
+    try {
+      await runtime.initialize();
+      return runtime;
+    } catch (error) {
+      await runtime.dispose();
+      throw new StealthWaitUnavailableError(error);
+    }
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.contextsByFrame.clear();
+    await this.session.detach().catch(() => void 0);
+  }
+  async waitForMainFrameVisualStability(options) {
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
+    if (timeout <= 0) return;
+    const frameRecords = await this.getFrameRecords();
+    const mainFrame = frameRecords[0];
+    if (!mainFrame) return;
+    await this.waitForFrameVisualStability(mainFrame.frameId, timeout, settleMs);
+  }
+  async collectVisibleFrameIds() {
+    const frameRecords = await this.getFrameRecords();
+    if (frameRecords.length === 0) return [];
+    const visibleFrameIds = [];
+    for (const frameRecord of frameRecords) {
+      if (!frameRecord.parentFrameId) {
+        visibleFrameIds.push(frameRecord.frameId);
+        continue;
+      }
+      try {
+        const parentContextId = await this.ensureFrameContextId(
+          frameRecord.parentFrameId
+        );
+        const visible = await this.isFrameOwnerVisible(
+          frameRecord.frameId,
+          parentContextId
+        );
+        if (visible) {
+          visibleFrameIds.push(frameRecord.frameId);
+        }
+      } catch (error) {
+        if (isIgnorableFrameError(error)) continue;
+        throw error;
+      }
+    }
+    return visibleFrameIds;
+  }
+  async waitForFrameVisualStability(frameId, timeout, settleMs) {
+    if (timeout <= 0) return;
+    const script = buildStabilityScript(timeout, settleMs);
+    let contextId = await this.ensureFrameContextId(frameId);
+    try {
+      await this.evaluateWithGuard(contextId, script, timeout);
+    } catch (error) {
+      if (!isMissingExecutionContextError(error)) {
+        throw error;
+      }
+      this.contextsByFrame.delete(frameId);
+      contextId = await this.ensureFrameContextId(frameId);
+      await this.evaluateWithGuard(contextId, script, timeout);
+    }
+  }
+  async initialize() {
+    await this.session.send("Page.enable");
+    await this.session.send("Runtime.enable");
+    await this.session.send("DOM.enable");
+  }
+  async getFrameRecords() {
+    const treeResult = await this.session.send("Page.getFrameTree");
+    const records = [];
+    walkFrameTree(treeResult.frameTree, null, records);
+    return records;
+  }
+  async ensureFrameContextId(frameId) {
+    const cached = this.contextsByFrame.get(frameId);
+    if (cached != null) {
+      return cached;
+    }
+    const world = await this.session.send("Page.createIsolatedWorld", {
+      frameId,
+      worldName: STEALTH_WORLD_NAME
+    });
+    this.contextsByFrame.set(frameId, world.executionContextId);
+    return world.executionContextId;
+  }
+  async evaluateWithGuard(contextId, script, timeout) {
+    const evaluationPromise = this.evaluateScript(contextId, script);
+    const settledPromise = evaluationPromise.then(
+      () => ({ kind: "resolved" }),
+      (error) => ({ kind: "rejected", error })
+    );
+    const timeoutPromise = sleep(
+      timeout + FRAME_EVALUATE_GRACE_MS
+    ).then(() => ({ kind: "timeout" }));
+    const result = await Promise.race([
+      settledPromise,
+      timeoutPromise
+    ]);
+    if (result.kind === "rejected") {
+      throw result.error;
+    }
+  }
+  async evaluateScript(contextId, expression) {
+    const result = await this.session.send("Runtime.evaluate", {
+      contextId,
+      expression,
+      awaitPromise: true,
+      returnByValue: true
+    });
+    if (result.exceptionDetails) {
+      throw new Error(formatCdpException(result.exceptionDetails));
+    }
+  }
+  async isFrameOwnerVisible(frameId, parentContextId) {
+    const owner = await this.session.send("DOM.getFrameOwner", {
+      frameId
+    });
+    const resolveParams = {
+      executionContextId: parentContextId
+    };
+    if (typeof owner.backendNodeId === "number") {
+      resolveParams.backendNodeId = owner.backendNodeId;
+    } else if (typeof owner.nodeId === "number") {
+      resolveParams.nodeId = owner.nodeId;
+    } else {
+      return false;
+    }
+    const resolved = await this.session.send(
+      "DOM.resolveNode",
+      resolveParams
+    );
+    const objectId = resolved.object?.objectId;
+    if (!objectId) return false;
+    try {
+      const callResult = await this.session.send("Runtime.callFunctionOn", {
+        objectId,
+        functionDeclaration: FRAME_OWNER_VISIBILITY_FUNCTION,
+        returnByValue: true
+      });
+      if (callResult.exceptionDetails) {
+        throw new Error(formatCdpException(callResult.exceptionDetails));
+      }
+      return callResult.result.value === true;
+    } finally {
+      await this.releaseObject(objectId);
+    }
+  }
+  async releaseObject(objectId) {
+    await this.session.send("Runtime.releaseObject", {
+      objectId
+    }).catch(() => void 0);
+  }
+};
 async function waitForVisualStability(page, options = {}) {
-  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
-  const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
-  await waitForFrameVisualStability(page.mainFrame(), {
-    timeout,
-    settleMs
-  });
+  const runtime = await StealthCdpRuntime.create(page);
+  try {
+    await runtime.waitForMainFrameVisualStability(options);
+  } finally {
+    await runtime.dispose();
+  }
 }
 async function waitForVisualStabilityAcrossFrames(page, options = {}) {
   const timeout = options.timeout ?? DEFAULT_TIMEOUT;
   const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
+  if (timeout <= 0) return;
   const deadline = Date.now() + timeout;
-  while (true) {
-    const remaining = Math.max(0, deadline - Date.now());
-    if (remaining === 0) return;
-    const frames = page.frames();
-    await Promise.all(
-      frames.map(async (frame) => {
-        try {
-          await waitForFrameVisualStability(frame, {
-            timeout: remaining,
-            settleMs
-          });
-        } catch (error) {
-          if (isIgnorableFrameError(error)) return;
-          throw error;
-        }
-      })
-    );
-    const currentFrames = page.frames();
-    if (sameFrames(frames, currentFrames)) {
-      return;
+  const runtime = await StealthCdpRuntime.create(page);
+  try {
+    while (true) {
+      const remaining = Math.max(0, deadline - Date.now());
+      if (remaining === 0) return;
+      const frameIds = await runtime.collectVisibleFrameIds();
+      if (frameIds.length === 0) return;
+      await Promise.all(
+        frameIds.map(async (frameId) => {
+          try {
+            await runtime.waitForFrameVisualStability(
+              frameId,
+              remaining,
+              settleMs
+            );
+          } catch (error) {
+            if (isIgnorableFrameError(error)) return;
+            throw error;
+          }
+        })
+      );
+      const currentFrameIds = await runtime.collectVisibleFrameIds();
+      if (sameFrameIds(frameIds, currentFrameIds)) {
+        return;
+      }
     }
+  } finally {
+    await runtime.dispose();
   }
 }
-async function waitForFrameVisualStability(frame, options) {
-  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
-  const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
-  if (timeout <= 0) return;
-  await frame.evaluate(buildStabilityScript(timeout, settleMs));
+function walkFrameTree(node, parentFrameId, records) {
+  const frameId = node.frame?.id;
+  if (!frameId) return;
+  records.push({
+    frameId,
+    parentFrameId
+  });
+  for (const child of node.childFrames ?? []) {
+    walkFrameTree(child, frameId, records);
+  }
 }
-function sameFrames(before, after) {
+function sameFrameIds(before, after) {
   if (before.length !== after.length) return false;
-  for (const frame of before) {
-    if (!after.includes(frame)) return false;
+  for (const frameId of before) {
+    if (!after.includes(frameId)) return false;
   }
   return true;
 }
+function formatCdpException(details) {
+  return details.exception?.description || details.text || "CDP runtime evaluation failed.";
+}
+function isMissingExecutionContextError(error) {
+  if (!(error instanceof Error)) return false;
+  const message = error.message;
+  return message.includes("Cannot find context with specified id") || message.includes("Cannot find execution context");
+}
 function isIgnorableFrameError(error) {
   if (!(error instanceof Error)) return false;
   const message = error.message;
-  return message.includes("Frame was detached") || message.includes("Execution context was destroyed") || message.includes("Target page, context or browser has been closed");
+  return message.includes("Frame was detached") || message.includes("Execution context was destroyed") || message.includes("Target page, context or browser has been closed") || message.includes("Cannot find context with specified id") || message.includes("Cannot find execution context") || message.includes("No frame for given id found");
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
 }
 
 // src/storage/registry.ts
@@ -1114,6 +1446,66 @@ var OS_BOUNDARY_ATTR = "data-os-boundary";
 var OS_UNAVAILABLE_ATTR = "data-os-unavailable";
 var OS_IFRAME_BOUNDARY_TAG = "os-iframe-root";
 var OS_SHADOW_BOUNDARY_TAG = "os-shadow-root";
+function decodeSerializedNodeTableEntry(nodeTable, rawIndex, label) {
+  if (typeof rawIndex !== "number" || !Number.isInteger(rawIndex) || rawIndex < 0 || rawIndex >= nodeTable.length) {
+    throw new Error(
+      `Invalid serialized path node index at "${label}": expected a valid table index.`
+    );
+  }
+  const node = nodeTable[rawIndex];
+  if (!node || typeof node !== "object") {
+    throw new Error(
+      `Invalid serialized path node at "${label}": table entry is missing.`
+    );
+  }
+  return node;
+}
+function decodeSerializedDomPath(nodeTable, rawPath, label) {
+  if (!Array.isArray(rawPath)) {
+    throw new Error(
+      `Invalid serialized path at "${label}": expected an array of node indexes.`
+    );
+  }
+  return rawPath.map(
+    (value, index) => decodeSerializedNodeTableEntry(nodeTable, value, `${label}[${index}]`)
+  );
+}
+function decodeSerializedElementPath(nodeTable, rawPath, label) {
+  if (!rawPath || typeof rawPath !== "object") {
+    throw new Error(
+      `Invalid serialized element path at "${label}": expected an object.`
+    );
+  }
+  if (rawPath.context !== void 0 && !Array.isArray(rawPath.context)) {
+    throw new Error(
+      `Invalid serialized context at "${label}.context": expected an array.`
+    );
+  }
+  const contextRaw = Array.isArray(rawPath.context) ? rawPath.context : [];
+  const context = contextRaw.map((hop, hopIndex) => {
+    if (!hop || typeof hop !== "object" || hop.kind !== "shadow") {
+      throw new Error(
+        `Invalid serialized context hop at "${label}.context[${hopIndex}]": expected a shadow hop.`
+      );
+    }
+    return {
+      kind: "shadow",
+      host: decodeSerializedDomPath(
+        nodeTable,
+        hop.host,
+        `${label}.context[${hopIndex}].host`
+      )
+    };
+  });
+  return {
+    context,
+    nodes: decodeSerializedDomPath(
+      nodeTable,
+      rawPath.nodes,
+      `${label}.nodes`
+    )
+  };
+}
 async function serializePageHTML(page, _options = {}) {
   return serializeFrameRecursive(page.mainFrame(), [], "f0");
 }
@@ -1170,6 +1562,8 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
         (Array.isArray(deferredMatchAttrKeys) ? deferredMatchAttrKeys : []).map((key) => String(key))
       );
       let counter = 1;
+      const nodeTable = [];
+      const nodeTableIndexByKey = /* @__PURE__ */ new Map();
       const entries = [];
       const helpers = {
         nextToken() {
@@ -1371,6 +1765,47 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
             nodes: target
           };
         },
+        buildPathNodeKey(node) {
+          const attrs = Object.entries(node.attrs || {}).sort(
+            ([a], [b]) => a.localeCompare(b)
+          );
+          const match = (node.match || []).map(
+            (clause) => clause.kind === "attr" ? [
+              "attr",
+              clause.key,
+              clause.op || "exact",
+              clause.value ?? null
+            ] : ["position", clause.axis]
+          );
+          return JSON.stringify([
+            node.tag,
+            node.position.nthChild,
+            node.position.nthOfType,
+            attrs,
+            match
+          ]);
+        },
+        internPathNode(node) {
+          const key = helpers.buildPathNodeKey(node);
+          const existing = nodeTableIndexByKey.get(key);
+          if (existing != null) return existing;
+          const index = nodeTable.length;
+          nodeTable.push(node);
+          nodeTableIndexByKey.set(key, index);
+          return index;
+        },
+        packDomPath(path5) {
+          return path5.map((node) => helpers.internPathNode(node));
+        },
+        packElementPath(path5) {
+          return {
+            context: (path5.context || []).map((hop) => ({
+              kind: "shadow",
+              host: helpers.packDomPath(hop.host)
+            })),
+            nodes: helpers.packDomPath(path5.nodes)
+          };
+        },
         ensureNodeId(el) {
           const next = `${frameKey2}_${counter++}`;
           el.setAttribute(nodeAttr, next);
@@ -1400,9 +1835,12 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
         serializeElement(el) {
           const nodeId = helpers.ensureNodeId(el);
           const instanceToken = helpers.setInstanceToken(el);
+          const packedPath = helpers.packElementPath(
+            helpers.buildElementPath(el)
+          );
           entries.push({
             nodeId,
-            path: helpers.buildElementPath(el),
+            path: packedPath,
             instanceToken
           });
           const tag = el.tagName.toLowerCase();
@@ -1430,11 +1868,12 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
       win[frameTokenKey] = frameToken;
       const root = document.documentElement;
       if (!root) {
-        return { html: "", frameToken, entries };
+        return { html: "", frameToken, nodeTable, entries };
       }
       return {
         html: helpers.serializeElement(root),
         frameToken,
+        nodeTable,
         entries
       };
     },
@@ -1452,13 +1891,18 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
   );
   const nodePaths = /* @__PURE__ */ new Map();
   const nodeMeta = /* @__PURE__ */ new Map();
-  for (const entry of frameSnapshot.entries) {
+  for (const [index, entry] of frameSnapshot.entries.entries()) {
+    const path5 = decodeSerializedElementPath(
+      frameSnapshot.nodeTable,
+      entry.path,
+      `entries[${index}].path`
+    );
     nodePaths.set(entry.nodeId, {
       context: [
         ...baseContext,
-        ...entry.path.context || []
+        ...path5.context || []
       ],
-      nodes: entry.path.nodes
+      nodes: path5.nodes
     });
     nodeMeta.set(entry.nodeId, {
       frameToken: frameSnapshot.frameToken,
@@ -3854,7 +4298,7 @@ async function performInput(page, path5, options) {
       await resolved.element.type(options.text);
     }
     if (options.pressEnter) {
-      await resolved.element.press("Enter");
+      await resolved.element.press("Enter", { noWaitAfter: true });
     }
     return {
       ok: true,
@@ -4814,16 +5258,18 @@ var CACHE_IMPORT_BATCH_SIZE = 200;
 var RemoteSessionClient = class {
   baseUrl;
   key;
-  constructor(baseUrl, key) {
+  authScheme;
+  constructor(baseUrl, key, authScheme = "api-key") {
     this.baseUrl = normalizeBaseUrl(baseUrl);
     this.key = key;
+    this.authScheme = authScheme;
   }
   async create(request) {
     const response = await fetch(`${this.baseUrl}/sessions`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
-        "x-api-key": this.key
+        ...this.authHeaders()
       },
       body: JSON.stringify(request)
     });
@@ -4836,7 +5282,7 @@ var RemoteSessionClient = class {
     const response = await fetch(`${this.baseUrl}/sessions/${sessionId}`, {
       method: "DELETE",
       headers: {
-        "x-api-key": this.key
+        ...this.authHeaders()
       }
     });
     if (response.status === 204) {
@@ -4866,7 +5312,7 @@ var RemoteSessionClient = class {
       method: "POST",
       headers: {
         "content-type": "application/json",
-        "x-api-key": this.key
+        ...this.authHeaders()
       },
       body: JSON.stringify({ entries })
     });
@@ -4875,6 +5321,16 @@ var RemoteSessionClient = class {
     }
     return await response.json();
   }
+  authHeaders() {
+    if (this.authScheme === "bearer") {
+      return {
+        authorization: `Bearer ${this.key}`
+      };
+    }
+    return {
+      "x-api-key": this.key
+    };
+  }
 };
 function normalizeBaseUrl(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
@@ -5496,11 +5952,33 @@ function parseMode(value, source) {
     `Invalid ${source} value "${value}". Use "local" or "remote".`
   );
 }
+function parseAuthScheme(value, source) {
+  if (value == null) return void 0;
+  if (typeof value !== "string") {
+    throw new Error(
+      `Invalid ${source} value "${String(value)}". Use "api-key" or "bearer".`
+    );
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return void 0;
+  if (normalized === "api-key" || normalized === "bearer") {
+    return normalized;
+  }
+  throw new Error(
+    `Invalid ${source} value "${value}". Use "api-key" or "bearer".`
+  );
+}
 function resolveOpensteerApiKey() {
   const value = process.env.OPENSTEER_API_KEY?.trim();
   if (!value) return void 0;
   return value;
 }
+function resolveOpensteerAuthScheme() {
+  return parseAuthScheme(
+    process.env.OPENSTEER_AUTH_SCHEME,
+    "OPENSTEER_AUTH_SCHEME"
+  );
+}
 function normalizeRemoteOptions(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
@@ -5560,7 +6038,12 @@ function resolveConfig(input = {}) {
   const mergedWithEnv = mergeDeep(mergedWithFile, envConfig);
   const resolved = mergeDeep(mergedWithEnv, input);
   const envApiKey = resolveOpensteerApiKey();
+  const envAuthScheme = resolveOpensteerAuthScheme();
   const inputRemoteOptions = normalizeRemoteOptions(input.remote);
+  const inputAuthScheme = parseAuthScheme(
+    inputRemoteOptions?.authScheme,
+    "remote.authScheme"
+  );
   const inputHasRemoteApiKey = Boolean(
     inputRemoteOptions && Object.prototype.hasOwnProperty.call(inputRemoteOptions, "apiKey")
   );
@@ -5568,8 +6051,12 @@ function resolveConfig(input = {}) {
     mode: resolved.mode
   });
   if (modeSelection.mode === "remote") {
-    const resolvedRemote = normalizeRemoteOptions(resolved.remote);
-    resolved.remote = resolvedRemote ?? {};
+    const resolvedRemote = normalizeRemoteOptions(resolved.remote) ?? {};
+    const authScheme = inputAuthScheme ?? envAuthScheme ?? parseAuthScheme(resolvedRemote.authScheme, "remote.authScheme") ?? "api-key";
+    resolved.remote = {
+      ...resolvedRemote,
+      authScheme
+    };
   }
   if (envApiKey && modeSelection.mode === "remote" && !inputHasRemoteApiKey) {
     resolved.remote = {
@@ -5648,7 +6135,26 @@ var ACTION_WAIT_PROFILES = {
   type: ROBUST_PROFILE
 };
 var NETWORK_POLL_MS = 50;
-var IGNORED_RESOURCE_TYPES = /* @__PURE__ */ new Set(["websocket", "eventsource"]);
+var NETWORK_RELAX_AFTER_MS = 1800;
+var RELAXED_ALLOWED_PENDING = 2;
+var HEAVY_VISUAL_REQUEST_WINDOW_MS = 5e3;
+var TRACKED_RESOURCE_TYPES = /* @__PURE__ */ new Set([
+  "document",
+  "fetch",
+  "xhr",
+  "stylesheet",
+  "image",
+  "font",
+  "media"
+]);
+var HEAVY_RESOURCE_TYPES = /* @__PURE__ */ new Set(["document", "fetch", "xhr"]);
+var HEAVY_VISUAL_RESOURCE_TYPES = /* @__PURE__ */ new Set([
+  "stylesheet",
+  "image",
+  "font",
+  "media"
+]);
+var IGNORED_RESOURCE_TYPES = /* @__PURE__ */ new Set(["websocket", "eventsource", "manifest"]);
 var NOOP_SESSION = {
   async wait() {
   },
@@ -5658,7 +6164,7 @@ var NOOP_SESSION = {
 function createPostActionWaitSession(page, action, override) {
   const profile = resolveActionWaitProfile(action, override);
   if (!profile.enabled) return NOOP_SESSION;
-  const tracker = profile.includeNetwork ? new ScopedNetworkTracker(page) : null;
+  const tracker = profile.includeNetwork ? new AdaptiveNetworkTracker(page) : null;
   tracker?.start();
   let settled = false;
   return {
@@ -5666,19 +6172,32 @@ function createPostActionWaitSession(page, action, override) {
       if (settled) return;
       settled = true;
       const deadline = Date.now() + profile.timeout;
-      const networkWait = tracker ? tracker.waitForQuiet({
-        deadline,
-        quietMs: profile.networkQuietMs
-      }) : Promise.resolve();
+      const visualTimeout = profile.includeNetwork ? Math.min(
+        profile.timeout,
+        resolveNetworkBackedVisualTimeout(profile.settleMs)
+      ) : profile.timeout;
       try {
-        await Promise.all([
-          waitForVisualStabilityAcrossFrames(page, {
-            timeout: profile.timeout,
+        try {
+          await waitForVisualStabilityAcrossFrames(page, {
+            timeout: visualTimeout,
             settleMs: profile.settleMs
-          }),
-          networkWait
-        ]);
-      } catch {
+          });
+        } catch (error) {
+          if (isStealthWaitUnavailableError(error)) {
+            throw error;
+          }
+        } finally {
+          tracker?.freezeCollection();
+        }
+        if (tracker) {
+          try {
+            await tracker.waitForQuiet({
+              deadline,
+              quietMs: profile.networkQuietMs
+            });
+          } catch {
+          }
+        }
       } finally {
         tracker?.stop();
       }
@@ -5718,53 +6237,70 @@ function normalizeMs(value, fallback) {
   }
   return Math.max(0, Math.floor(value));
 }
-var ScopedNetworkTracker = class {
+function resolveNetworkBackedVisualTimeout(settleMs) {
+  const derived = settleMs * 3 + 300;
+  return Math.max(1200, Math.min(2500, derived));
+}
+var AdaptiveNetworkTracker = class {
   constructor(page) {
     this.page = page;
   }
-  pending = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Map();
   started = false;
+  collecting = false;
+  startedAt = 0;
   idleSince = Date.now();
   start() {
     if (this.started) return;
     this.started = true;
+    this.collecting = true;
+    this.startedAt = Date.now();
+    this.idleSince = this.startedAt;
     this.page.on("request", this.handleRequestStarted);
     this.page.on("requestfinished", this.handleRequestFinished);
     this.page.on("requestfailed", this.handleRequestFinished);
   }
+  freezeCollection() {
+    if (!this.started) return;
+    this.collecting = false;
+  }
   stop() {
     if (!this.started) return;
     this.started = false;
+    this.collecting = false;
     this.page.off("request", this.handleRequestStarted);
     this.page.off("requestfinished", this.handleRequestFinished);
     this.page.off("requestfailed", this.handleRequestFinished);
     this.pending.clear();
+    this.startedAt = 0;
     this.idleSince = Date.now();
   }
   async waitForQuiet(options) {
     const quietMs = Math.max(0, options.quietMs);
     if (quietMs === 0) return;
     while (Date.now() < options.deadline) {
-      if (this.pending.size === 0) {
+      const now = Date.now();
+      const allowedPending = this.resolveAllowedPending(now);
+      if (this.pending.size <= allowedPending) {
         if (this.idleSince === 0) {
-          this.idleSince = Date.now();
+          this.idleSince = now;
         }
-        const idleFor = Date.now() - this.idleSince;
+        const idleFor = now - this.idleSince;
         if (idleFor >= quietMs) {
           return;
         }
       } else {
         this.idleSince = 0;
       }
-      const remaining = Math.max(1, options.deadline - Date.now());
-      await sleep(Math.min(NETWORK_POLL_MS, remaining));
+      const remaining = Math.max(1, options.deadline - now);
+      await sleep2(Math.min(NETWORK_POLL_MS, remaining));
     }
   }
   handleRequestStarted = (request) => {
-    if (!this.started) return;
-    const resourceType = request.resourceType();
-    if (IGNORED_RESOURCE_TYPES.has(resourceType)) return;
-    this.pending.add(request);
+    if (!this.started || !this.collecting) return;
+    const trackedRequest = this.classifyRequest(request);
+    if (!trackedRequest) return;
+    this.pending.set(request, trackedRequest);
     this.idleSince = 0;
   };
   handleRequestFinished = (request) => {
@@ -5774,8 +6310,35 @@ var ScopedNetworkTracker = class {
       this.idleSince = Date.now();
     }
   };
+  classifyRequest(request) {
+    const resourceType = request.resourceType().toLowerCase();
+    if (IGNORED_RESOURCE_TYPES.has(resourceType)) return null;
+    if (!TRACKED_RESOURCE_TYPES.has(resourceType)) return null;
+    const frame = request.frame();
+    if (!frame || frame !== this.page.mainFrame()) return null;
+    return {
+      resourceType,
+      startedAt: Date.now()
+    };
+  }
+  resolveAllowedPending(now) {
+    const relaxed = now - this.startedAt >= NETWORK_RELAX_AFTER_MS ? RELAXED_ALLOWED_PENDING : 0;
+    if (this.hasHeavyPending(now)) return 0;
+    return relaxed;
+  }
+  hasHeavyPending(now) {
+    for (const trackedRequest of this.pending.values()) {
+      if (HEAVY_RESOURCE_TYPES.has(trackedRequest.resourceType)) {
+        return true;
+      }
+      if (HEAVY_VISUAL_RESOURCE_TYPES.has(trackedRequest.resourceType) && now - trackedRequest.startedAt < HEAVY_VISUAL_REQUEST_WINDOW_MS) {
+        return true;
+      }
+    }
+    return false;
+  }
 };
-async function sleep(ms) {
+async function sleep2(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -6895,9 +7458,9 @@ function clonePersistedExtractNode(node) {
 
 // src/remote/runtime.ts
 var DEFAULT_REMOTE_BASE_URL = "https://remote.opensteer.com";
-function createRemoteRuntimeState(key, baseUrl = resolveRemoteBaseUrl()) {
+function createRemoteRuntimeState(key, baseUrl = resolveRemoteBaseUrl(), authScheme = "api-key") {
   return {
-    sessionClient: new RemoteSessionClient(baseUrl, key),
+    sessionClient: new RemoteSessionClient(baseUrl, key, authScheme),
     cdpClient: new RemoteCdpClient(),
     actionClient: null,
     sessionId: null
@@ -6962,7 +7525,8 @@ var Opensteer = class _Opensteer {
       }
       this.remote = createRemoteRuntimeState(
         apiKey,
-        remoteConfig?.baseUrl
+        remoteConfig?.baseUrl,
+        remoteConfig?.authScheme
       );
     } else {
       this.remote = null;
@@ -7418,7 +7982,7 @@ var Opensteer = class _Opensteer {
             await handle.type(options.text);
           }
           if (options.pressEnter) {
-            await handle.press("Enter");
+            await handle.press("Enter", { noWaitAfter: true });
           }
         });
       } catch (err) {