Bind CDP session creation to context receivers

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

Author: cursoragent

currentState.md

@@ -171,6 +171,10 @@ HyperAgent exposes a TypeScript SDK for browser automation with three primary pa
 - Hardened element-locator debug frame listing:
   - trap-prone frame arrays no longer collapse the entire debug "Available frames" payload,
   - readable frame entries are preserved even when individual frame getters/indexes trap.
+- Bound CDP session creation to context receivers in both discovery paths:
+  - `PlaywrightCDPClient.createSession()` now calls `newCDPSession` with the browser context receiver explicitly.
+  - `FrameContextManager.captureOOPIFs()` now calls `newCDPSession` with the discovered context receiver explicitly.
+  - Added regressions proving receiver-sensitive `newCDPSession` implementations continue to work.
 - 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/cdp/frame-context-manager.test.ts

@@ -395,6 +395,42 @@ describe("FrameContextManager listener bookkeeping", () => {
     }
   });
 
+  it("captureOOPIFs uses the browser-context receiver for session creation", async () => {
+    const session = new FakeSession();
+    const mainFrame = {
+      url: () => "https://example.com",
+      parentFrame: () => null,
+      name: () => "main",
+      isDetached: () => false,
+    };
+    const sameOriginFrame = {
+      url: () => "https://example.com/child",
+      parentFrame: () => mainFrame,
+      name: () => "child",
+      isDetached: () => false,
+    };
+    const context = {
+      newCDPSession: jest.fn(function (this: unknown, frame: unknown) {
+        if (this !== context) {
+          throw new Error("invalid context receiver");
+        }
+        void frame;
+        return Promise.reject(new Error("same origin frame"));
+      }),
+    };
+    const page = {
+      context: () => context,
+      frames: () => [mainFrame, sameOriginFrame],
+      mainFrame: () => mainFrame,
+    };
+    const manager = new FrameContextManager(
+      createFakeClientWithPage(session, page)
+    );
+
+    await expect(manager.captureOOPIFs(1)).resolves.toBeUndefined();
+    expect(context.newCDPSession).toHaveBeenCalledWith(sameOriginFrame);
+  });
+
   it("captureOOPIFs skips ad/tracking frame session creation by default", async () => {
     const session = new FakeSession();
     const mainFrame = {

src/cdp/frame-context-manager.ts

@@ -650,9 +650,10 @@ export class FrameContextManager {
       try {
         oopifSession = await (
           newCDPSessionMethod as (
+            this: object,
             frameArg: PlaywrightFrameHandle
           ) => Promise<CDPSession>
-        )(frame);
+        ).call(contextUnknown as object, frame);
       } catch {
         // Failed to create session = same-origin frame (already processed via DOM.getDocument)
         this.log(`[FrameContext] Frame ${frameUrl} is same-origin, skipping`);

src/cdp/playwright-adapter.test.ts

@@ -186,4 +186,30 @@ describe("playwright adapter error formatting", () => {
       warnSpy.mockRestore();
     }
   });
+
+  it("creates CDP sessions with the browser-context receiver", async () => {
+    const session = {
+      send: jest.fn().mockResolvedValue({}),
+      on: jest.fn(),
+      off: jest.fn(),
+      detach: jest.fn().mockResolvedValue(undefined),
+    } as unknown as PlaywrightSession;
+    const context = {
+      newCDPSession: jest.fn(function (this: unknown, target: unknown) {
+        if (this !== context) {
+          throw new Error("invalid context receiver");
+        }
+        void target;
+        return Promise.resolve(session);
+      }),
+    };
+    const page = {
+      context: () => context,
+      once: jest.fn(),
+    } as unknown as Page;
+
+    const client = await getCDPClientForPage(page);
+    await expect(client.acquireSession("lifecycle")).resolves.toBeDefined();
+    expect(context.newCDPSession).toHaveBeenCalled();
+  });
 });

src/cdp/playwright-adapter.ts

@@ -198,8 +198,11 @@ class PlaywrightCDPClient implements CDPClient {
     let session: PlaywrightSession;
     try {
       session = (await (
-        newCDPSessionMethod as (targetArg: Page | Frame) => Promise<PlaywrightSession>
-      )(target)) as PlaywrightSession;
+        newCDPSessionMethod as (
+          this: object,
+          targetArg: Page | Frame
+        ) => Promise<PlaywrightSession>
+      ).call(pageContext as object, target)) as PlaywrightSession;
     } catch (error) {
       throw new Error(
         `[CDP][PlaywrightAdapter] Failed to create CDP session: ${formatPlaywrightAdapterDiagnostic(