Refine settle context probing warning behavior

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

currentState.md

@@ -152,6 +152,7 @@ HyperAgent exposes a TypeScript SDK for browser automation with three primary pa
 - Aligned settle network-tracing behavior so recording-video sessions now propagate trace mode into network-idle diagnostics (including stalled-request warnings) even when debug flags are off.
 - Expanded settle trace regressions with cleaner log-capture coverage to ensure recording-video trace diagnostics remain validated without noisy test output.
 - Hardened settle debug-option lookup against trap-prone `getDebugOptions()` reads, with deterministic fallback trace defaults and sanitized warning diagnostics.
+- Refined settle context probing to avoid noisy warnings when `page.context` is unavailable while still surfacing sanitized diagnostics for trap-prone context method/getter failures.
 - Hardened A11y DOM option ingestion (`useCache`, `onFrameChunk`, `filterAdTrackingFrames`) with trap-safe reads, so malformed option objects no longer break extraction setup.
 - Hardened A11y DOM debug-option lookup (`getDebugOptions`) with trap-safe fallback defaults and sanitized warning diagnostics.
 - Hardened OpenAI/Anthropic structured-schema debug-option reads so trap-prone debug-option access no longer interrupts structured invocation paths.

src/utils/waitForSettledDOM.test.ts

@@ -260,6 +260,89 @@ describe("waitForSettledDOM diagnostics", () => {
     }
   });
 
+  it("continues when page.context() getter throws", async () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const { session } = createSessionWithEvents();
+    const cdpClient: CDPClient = {
+      rootSession: session,
+      createSession: async () => session,
+      acquireSession: async () => session,
+      dispose: async () => undefined,
+    };
+    getCDPClient.mockResolvedValue(cdpClient);
+    getOrCreateFrameContextManager.mockReturnValue({
+      setDebug: jest.fn(),
+    });
+    getDebugOptions.mockReturnValue({
+      enabled: false,
+      traceWait: false,
+    });
+
+    const page = {
+      context: () => {
+        throw new Error(`context\u0000\n${"x".repeat(2_000)}`);
+      },
+    } as never;
+
+    try {
+      const waitPromise = waitForSettledDOM(page, 600);
+      await Promise.resolve();
+      await Promise.resolve();
+      await jest.advanceTimersByTimeAsync(700);
+      const stats = await waitPromise;
+
+      expect(stats.resolvedByTimeout).toBe(false);
+      const warning = String(
+        warnSpy.mock.calls.find((call) =>
+          String(call[0] ?? "").includes("Failed to read page context")
+        )?.[0] ?? ""
+      );
+      expect(warning).toContain("[truncated");
+      expect(warning).not.toContain("\u0000");
+      expect(warning).not.toContain("\n");
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it("does not warn when page.context method is unavailable", async () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const { session } = createSessionWithEvents();
+    const cdpClient: CDPClient = {
+      rootSession: session,
+      createSession: async () => session,
+      acquireSession: async () => session,
+      dispose: async () => undefined,
+    };
+    getCDPClient.mockResolvedValue(cdpClient);
+    getOrCreateFrameContextManager.mockReturnValue({
+      setDebug: jest.fn(),
+    });
+    getDebugOptions.mockReturnValue({
+      enabled: false,
+      traceWait: false,
+    });
+
+    const page = {} as never;
+
+    try {
+      const waitPromise = waitForSettledDOM(page, 600);
+      await Promise.resolve();
+      await Promise.resolve();
+      await jest.advanceTimersByTimeAsync(700);
+      const stats = await waitPromise;
+
+      expect(stats.resolvedByTimeout).toBe(false);
+      expect(
+        warnSpy.mock.calls.some((call) =>
+          String(call[0] ?? "").includes("Failed to read page context")
+        )
+      ).toBe(false);
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
   it("applies frame filtering option when provided", async () => {
     const { session } = createSessionWithEvents();
     const cdpClient: CDPClient = {

src/utils/waitForSettledDOM.ts

@@ -14,7 +14,7 @@
  * 6. Global timeout ensures we don't wait forever
  */
 
-import type { BrowserContext, Page } from "playwright-core";
+import type { Page } from "playwright-core";
 import { getCDPClient, getOrCreateFrameContextManager } from "@/cdp";
 import type { CDPSession } from "@/cdp";
 import { Protocol } from "devtools-protocol";
@@ -207,6 +207,51 @@ function readWaitDebugOptions(): { enabled: boolean; traceWait: boolean } {
   }
 }
 
+function hasRecordingVideoContext(page: Page): boolean {
+  let contextMethod: unknown;
+  try {
+    contextMethod = (
+      page as unknown as { context?: unknown }
+    ).context;
+  } catch (error) {
+    console.warn(
+      `[waitForSettledDOM] Failed to read page context method: ${formatWaitDiagnostic(
+        error
+      )}`
+    );
+    return false;
+  }
+  if (typeof contextMethod !== "function") {
+    return false;
+  }
+
+  let context: unknown;
+  try {
+    context = (contextMethod as (this: Page) => unknown).call(page);
+  } catch (error) {
+    console.warn(
+      `[waitForSettledDOM] Failed to read page context: ${formatWaitDiagnostic(
+        error
+      )}`
+    );
+    return false;
+  }
+  if (!context || typeof context !== "object") {
+    return false;
+  }
+  try {
+    const options = (context as { _options?: { recordVideo?: unknown } })._options;
+    return !!options?.recordVideo;
+  } catch (error) {
+    console.warn(
+      `[waitForSettledDOM] Failed to read context options: ${formatWaitDiagnostic(
+        error
+      )}`
+    );
+    return false;
+  }
+}
+
 function safeReadWaitOptionField(
   options: unknown,
   field: keyof WaitForSettledOptions
@@ -235,13 +280,10 @@ export async function waitForSettledDOM(
     typeof filterAdTrackingFramesOption === "boolean"
       ? filterAdTrackingFramesOption
       : undefined;
-  const ctx = page.context() as BrowserContext & {
-    _options?: { recordVideo?: unknown };
-  };
   const debugOptions = readWaitDebugOptions();
   const traceWaitFlag =
     (debugOptions.enabled && debugOptions.traceWait) || ENV_TRACE_WAIT;
-  const traceWait = traceWaitFlag || !!ctx._options?.recordVideo;
+  const traceWait = traceWaitFlag || hasRecordingVideoContext(page);
   const totalStart = performance.now();
 
   // Currently we only wait for network idle (historical behavior). Hook exists if we add DOM states later.