Guard cache-hydration debug setter in a11y provider

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

Author: cursoragent

currentState.md

@@ -201,6 +201,8 @@ HyperAgent exposes a TypeScript SDK for browser automation with three primary pa
   - `collectExecutionContexts()` now also guards trap-prone `session.send` reads for `Runtime.enable`, preventing getter traps from aborting the context collection path.
 - Hardened frame-sync debug handling in a11y context provider:
   - `syncFrameContextManager()` now guards trap-prone frame-manager `setDebug` calls, preserving sync flow with sanitized debug warnings.
+- Hardened cache-hydration debug handling in a11y context provider:
+  - `hydrateFrameContextFromSnapshot()` now guards trap-prone frame-manager `setDebug` calls so cache hydration continues instead of aborting early.
 - Refreshed remaining staged-flow wording in the CDP deep dive around OOPIF discovery to describe current execution-context sync progression without stale "Need Phase 4" phrasing.
 - Hardened CDP command dispatch in Playwright session adapter:
   - `PlaywrightSessionAdapter.send()` now guards trap-prone `session.send` method reads and wraps sync send failures with sanitized/diagnostic context.

src/context-providers/a11y-dom/index.test.ts

@@ -1,5 +1,6 @@
 import type { Page } from "playwright-core";
 import { getA11yDOM } from "@/context-providers/a11y-dom";
+import { domSnapshotCache } from "@/context-providers/a11y-dom/dom-cache";
 
 const getCDPClientMock = jest.fn();
 const getOrCreateFrameContextManagerMock = jest.fn();
@@ -472,4 +473,69 @@ describe("getA11yDOM error formatting", () => {
       errorSpy.mockRestore();
     }
   });
+
+  it("continues cache hydration when frame-manager debug setter traps", async () => {
+    const page = {
+      url: jest.fn(() => "https://example.com"),
+    } as unknown as Page;
+    const cachedState = {
+      domState: "cached dom",
+      elements: new Map(),
+      xpathMap: {},
+      backendNodeMap: {},
+      frameMap: new Map([
+        [
+          1,
+          {
+            frameIndex: 1,
+            siblingPosition: 0,
+            frameId: "frame-1",
+            xpath: "//iframe[1]",
+            parentFrameIndex: 0,
+          },
+        ],
+      ]),
+    } as unknown as Parameters<typeof domSnapshotCache.set>[1];
+    domSnapshotCache.set(page, cachedState);
+
+    const rootSession = {
+      id: "session-1",
+      send: jest.fn().mockResolvedValue({
+        frameTree: {
+          frame: {
+            id: "root-frame",
+            parentId: undefined,
+            loaderId: "loader-1",
+            name: "root",
+            url: "https://example.com",
+          },
+        },
+      }),
+    };
+    const ensureInitialized = jest.fn().mockResolvedValue(undefined);
+    getCDPClientMock.mockResolvedValue({
+      rootSession,
+    });
+    getOrCreateFrameContextManagerMock.mockReturnValue({
+      setDebug: jest.fn(() => {
+        throw new Error("cache-hydration debug trap");
+      }),
+      ensureInitialized,
+      upsertFrame: jest.fn(),
+      assignFrameIndex: jest.fn(),
+      setFrameSession: jest.fn(),
+      getFrameByBackendNodeId: jest.fn(),
+      getFrameSession: jest.fn(),
+    });
+
+    try {
+      const result = await getA11yDOM(page, false, false, undefined, {
+        useCache: true,
+      });
+      expect(result.domState).toBe("cached dom");
+      expect(ensureInitialized).toHaveBeenCalled();
+    } finally {
+      domSnapshotCache.invalidate(page);
+    }
+  });
 });

src/context-providers/a11y-dom/index.ts

@@ -495,7 +495,17 @@ async function hydrateFrameContextFromSnapshot(
   try {
     const cdpClient = await getCDPClient(page);
     const manager = getOrCreateFrameContextManager(cdpClient);
-    manager.setDebug(debug);
+    try {
+      manager.setDebug(debug);
+    } catch (error) {
+      if (debug) {
+        console.warn(
+          `[FrameContext] Failed to configure cache-hydration debug mode: ${formatA11yDiagnostic(
+            error
+          )}`
+        );
+      }
+    }
     await manager.ensureInitialized().catch(() => {});
     await syncFrameContextManager({
       manager,