@apifuse/provider-sdk 2.2.0-beta.5 → 2.2.0-beta.51

package/dist/runtime/browser.js

@@ -15,7 +15,7 @@ function toResourceBody(body) {
     return Buffer.from(body);
 }
 function isResourceMethod(method) {
-    return method === "GET" || method === "HEAD";
+    return method === "GET" || method === "HEAD" || method === "POST";
 }
 async function toResourceRequest(request) {
     const method = request.method().toUpperCase();
@@ -59,6 +59,68 @@ function getCdpPausedRequestId(params) {
     }
     return params.requestId;
 }
+function isCdpResponseStage(params) {
+    return (isRecord(params) &&
+        (typeof params.responseStatusCode === "number" ||
+            typeof params.responseErrorReason === "string"));
+}
+function toCdpPausedDocumentResponse(params) {
+    if (!isRecord(params) ||
+        typeof params.requestId !== "string" ||
+        typeof params.responseStatusCode !== "number" ||
+        params.resourceType !== "Document" ||
+        !isRecord(params.request)) {
+        return null;
+    }
+    const responseCode = params.responseStatusCode;
+    const responseHeaders = Array.isArray(params.responseHeaders)
+        ? params.responseHeaders.flatMap((header) => {
+            if (!isRecord(header) ||
+                typeof header.name !== "string" ||
+                typeof header.value !== "string") {
+                return [];
+            }
+            return [{ name: header.name, value: header.value }];
+        })
+        : [];
+    return {
+        hasBody: String(params.request.method ?? "").toUpperCase() !== "HEAD" &&
+            responseCode >= 200 &&
+            (responseCode < 300 || responseCode >= 400) &&
+            responseCode !== 204 &&
+            responseCode !== 205 &&
+            responseCode !== 304,
+        requestId: params.requestId,
+        responseCode,
+        responseHeaders,
+    };
+}
+function toCdpDocumentFulfillParams(response, body, contentSecurityPolicy) {
+    const responseBody = typeof body.body === "string" ? body.body : "";
+    return {
+        body: body.base64Encoded ? responseBody : Buffer.from(responseBody).toString("base64"),
+        requestId: response.requestId,
+        responseCode: response.responseCode,
+        responseHeaders: [
+            ...response.responseHeaders,
+            { name: "Content-Security-Policy", value: contentSecurityPolicy },
+        ],
+    };
+}
+function resourcePolicyFetchPatterns(policy) {
+    return [
+        { requestStage: "Request", urlPattern: "*" },
+        ...(policy.documentContentSecurityPolicy
+            ? [
+                {
+                    requestStage: "Response",
+                    resourceType: "Document",
+                    urlPattern: "*",
+                },
+            ]
+            : []),
+    ];
+}
 function toCdpResourceHeaders(value) {
     if (!isRecord(value)) {
         return {};
@@ -104,6 +166,128 @@ async function fulfillResourceRoute(route, decision) {
         status: decision.status ?? 200,
     });
 }
+async function decideResourceRequest(policy, request) {
+    for (const resourceRoute of policy.routes) {
+        if (matchesResourceRoute(resourceRoute.match, request)) {
+            return await resourceRoute.handle(request);
+        }
+    }
+    return { action: "block" };
+}
+async function abortResourceRoute(route) {
+    await route.abort("blockedbyclient");
+}
+async function handleCdpResourceRequest(session, policy, allowedMethods, params) {
+    const paused = toCdpResourceRequest(params);
+    const requestId = paused?.requestId ?? getCdpPausedRequestId(params);
+    if (!requestId)
+        return;
+    try {
+        if (!paused || !allowedMethods.has(paused.request.method)) {
+            await session.send("Fetch.failRequest", { errorReason: "BlockedByClient", requestId });
+            return;
+        }
+        const decision = await decideResourceRequest(policy, paused.request);
+        switch (decision.action) {
+            case "continue":
+                await session.send("Fetch.continueRequest", { requestId });
+                return;
+            case "fulfill":
+                await session.send("Fetch.fulfillRequest", toCdpFulfillParams(requestId, decision));
+                return;
+            case "block":
+                await session.send("Fetch.failRequest", { errorReason: "BlockedByClient", requestId });
+                return;
+        }
+    }
+    catch {
+        await session
+            .send("Fetch.failRequest", { errorReason: "BlockedByClient", requestId })
+            .catch(() => undefined);
+    }
+}
+async function handleCdpDocumentResponse(session, contentSecurityPolicy, params) {
+    const requestId = getCdpPausedRequestId(params);
+    if (!requestId)
+        return;
+    try {
+        const response = toCdpPausedDocumentResponse(params);
+        if (!response)
+            throw new Error("CDP document response metadata is unavailable");
+        if (!response.hasBody) {
+            await session.send("Fetch.continueResponse", {
+                requestId,
+                responseCode: response.responseCode,
+                responseHeaders: [...response.responseHeaders],
+            });
+            return;
+        }
+        const body = await session.send("Fetch.getResponseBody", {
+            requestId: response.requestId,
+        });
+        await session.send("Fetch.fulfillRequest", toCdpDocumentFulfillParams(response, body, contentSecurityPolicy));
+    }
+    catch {
+        await session
+            .send("Fetch.failRequest", { errorReason: "BlockedByClient", requestId })
+            .catch(() => undefined);
+    }
+}
+function getCdpAuthRequiredRequestId(params) {
+    if (!isRecord(params) || typeof params.requestId !== "string") {
+        return null;
+    }
+    return params.requestId;
+}
+function isCdpProxyAuthChallenge(params) {
+    return (isRecord(params) &&
+        isRecord(params.authChallenge) &&
+        params.authChallenge.source === "Proxy");
+}
+async function handleCdpAuthRequired(session, proxy, authAttempts, params) {
+    const requestId = getCdpAuthRequiredRequestId(params);
+    if (!requestId)
+        return;
+    // Chromium can emit another challenge after rejected credentials. Cancel a
+    // retry so incorrect credentials fail promptly instead of looping forever.
+    const response = isCdpProxyAuthChallenge(params) && !authAttempts.has(requestId)
+        ? (() => {
+            authAttempts.add(requestId);
+            return {
+                authChallengeResponse: {
+                    password: proxy.password,
+                    response: "ProvideCredentials",
+                    username: proxy.username,
+                },
+                requestId,
+            };
+        })()
+        : {
+            authChallengeResponse: { response: "CancelAuth" },
+            requestId,
+        };
+    await session.send("Fetch.continueWithAuth", response).catch(() => undefined);
+}
+function createResourcePolicyHandler(policy, allowedMethods) {
+    return async (route) => {
+        const request = await toResourceRequest(route.request());
+        if (!request || !allowedMethods.has(request.method)) {
+            await abortResourceRoute(route);
+            return;
+        }
+        const decision = await decideResourceRequest(policy, request);
+        switch (decision.action) {
+            case "continue":
+                await route.continue();
+                return;
+            case "fulfill":
+                await fulfillResourceRoute(route, decision);
+                return;
+            case "block":
+                await abortResourceRoute(route);
+        }
+    };
+}
 function getDefaultCdpPoolUrl(env = process.env) {
     return env.APIFUSE__CDP_POOL__URL;
 }
@@ -139,12 +323,60 @@ function formatExpression(fn) {
     }
     return `(${fn.toString()})()`;
 }
-function toLaunchOptions(options) {
+function toLaunchOptions(options, proxy) {
     return {
-        args: options.extraArgs,
+        // `extraArgs` is optional, but playwright-extra's stealth evasions mutate
+        // `options.args` unguarded (navigator.webdriver does
+        // `options.args.findIndex(...)` in beforeLaunch). Forwarding `undefined`
+        // therefore crashes every stealth launch that omits extraArgs with
+        // "TypeError: undefined is not an object (evaluating 'options.args.findIndex')".
+        // Always hand the launcher a concrete array.
+        args: options.extraArgs ?? [],
         executablePath: options.executablePath,
         headless: options.headless ?? true,
-        proxy: options.proxy ? { server: options.proxy } : undefined,
+        proxy,
+    };
+}
+function hasProxyCredentials(proxy) {
+    return proxy?.username !== undefined && proxy.password !== undefined;
+}
+function toPlaywrightProxy(proxy) {
+    if (!proxy)
+        return undefined;
+    const schemeEnd = proxy.indexOf("://");
+    const authorityStart = schemeEnd >= 0 ? schemeEnd + 3 : 0;
+    const remainder = proxy.slice(authorityStart);
+    const authorityEnd = remainder.search(/[/?#]/);
+    const authority = remainder.slice(0, authorityEnd >= 0 ? authorityEnd : undefined);
+    if (!authority.includes("@")) {
+        return { server: proxy };
+    }
+    let parsed;
+    try {
+        parsed = new URL(proxy);
+    }
+    catch {
+        throw new ProviderError("Browser proxy URL is invalid", {
+            code: "BROWSER_PROXY_INVALID",
+            fix: "Use a valid proxy URL.",
+        });
+    }
+    let username;
+    let password;
+    try {
+        username = decodeURIComponent(parsed.username);
+        password = decodeURIComponent(parsed.password);
+    }
+    catch {
+        throw new ProviderError("Browser proxy credentials use invalid percent-encoding", {
+            code: "BROWSER_PROXY_INVALID",
+            fix: "Percent-encode the proxy username and password as URL userinfo.",
+        });
+    }
+    return {
+        server: `${parsed.protocol}//${parsed.host}`,
+        username,
+        password,
     };
 }
 class PlaywrightBrowserLocator {
@@ -309,13 +541,15 @@ async function loadSeleniumBase() {
 }
 class PlaywrightBrowserPage {
     page;
+    proxy;
     id = "main";
     pageId;
-    constructor(page) {
+    constructor(page, proxy = undefined) {
         this.page = page;
+        this.proxy = proxy;
     }
-    async goto(url) {
-        await this.page.goto(url);
+    async goto(url, options) {
+        await this.page.goto(url, options);
     }
     async evaluate(fn) {
         if (typeof fn === "string") {
@@ -323,6 +557,9 @@ class PlaywrightBrowserPage {
         }
         return await this.page.evaluate(fn);
     }
+    async userAgent() {
+        return await this.evaluate("navigator.userAgent");
+    }
     async waitForSelector(selector, options) {
         await this.page.waitForSelector(selector, options);
     }
@@ -357,42 +594,107 @@ class PlaywrightBrowserPage {
     async close() {
         await this.page.close();
     }
+    async cookies() {
+        return (await this.page.context().cookies()).map(toBrowserCookie);
+    }
     async withResourcePolicy(policy, run) {
         const allowedMethods = new Set(policy.allowedMethods ?? DEFAULT_RESOURCE_METHODS);
+        const policyHandler = createResourcePolicyHandler(policy, allowedMethods);
+        const context = this.page.context();
         const handler = async (route) => {
-            const request = await toResourceRequest(route.request());
-            if (!request || !allowedMethods.has(request.method)) {
-                await route.abort("blockedbyclient");
+            try {
+                // Context routing sees a popup's first request before the late `page`
+                // event. Fail every secondary page closed so no redirect can escape
+                // the per-page CDP interception while that session is being attached.
+                if (route.request().frame().page() !== this.page) {
+                    await abortResourceRoute(route);
+                    return;
+                }
+            }
+            catch {
+                await abortResourceRoute(route);
                 return;
             }
-            for (const resourceRoute of policy.routes) {
-                if (!matchesResourceRoute(resourceRoute.match, request)) {
-                    continue;
+            await policyHandler(route);
+        };
+        const sessions = new Set();
+        const pendingAttachments = new Set();
+        const proxy = hasProxyCredentials(this.proxy) ? this.proxy : undefined;
+        let active = true;
+        const attachPage = async (page) => {
+            const session = await context.newCDPSession(page);
+            if (!active) {
+                await session.detach();
+                return;
+            }
+            const onRequestPaused = (params) => {
+                if (isCdpResponseStage(params) && policy.documentContentSecurityPolicy) {
+                    void handleCdpDocumentResponse(session, policy.documentContentSecurityPolicy, params);
+                    return;
                 }
-                const decision = await resourceRoute.handle(request);
-                switch (decision.action) {
-                    case "fulfill":
-                        await fulfillResourceRoute(route, decision);
-                        return;
-                    case "block":
-                        await route.abort("blockedbyclient");
-                        return;
+                void handleCdpResourceRequest(session, policy, allowedMethods, params);
+            };
+            const authAttempts = new Set();
+            const onAuthRequired = (params) => {
+                if (!proxy)
+                    return;
+                void handleCdpAuthRequired(session, proxy, authAttempts, params);
+            };
+            session.on("Fetch.requestPaused", onRequestPaused);
+            if (proxy) {
+                session.on("Fetch.authRequired", onAuthRequired);
+            }
+            try {
+                await session.send("Fetch.enable", {
+                    ...(proxy ? { handleAuthRequests: true } : {}),
+                    patterns: resourcePolicyFetchPatterns(policy),
+                });
+                sessions.add(session);
+            }
+            catch (error) {
+                session.off("Fetch.requestPaused", onRequestPaused);
+                if (proxy) {
+                    session.off("Fetch.authRequired", onAuthRequired);
                 }
+                await session.detach().catch(() => undefined);
+                throw error;
             }
-            await route.abort("blockedbyclient");
         };
-        await this.page.route(RESOURCE_POLICY_ROUTE_PATTERN, handler);
+        const onPage = (page) => {
+            const attachment = attachPage(page)
+                .catch(async () => {
+                await page.close().catch(() => undefined);
+            })
+                .finally(() => pendingAttachments.delete(attachment));
+            pendingAttachments.add(attachment);
+        };
+        await context.route(RESOURCE_POLICY_ROUTE_PATTERN, handler);
         try {
-            return await run();
+            context.on("page", onPage);
+            try {
+                await attachPage(this.page);
+                return await run();
+            }
+            finally {
+                context.off("page", onPage);
+            }
         }
         finally {
-            await this.page.unroute(RESOURCE_POLICY_ROUTE_PATTERN, handler);
+            active = false;
+            await context.unroute(RESOURCE_POLICY_ROUTE_PATTERN, handler);
+            await Promise.allSettled(pendingAttachments);
+            await Promise.all([...sessions].map(async (session) => {
+                await session.send("Fetch.disable").catch(() => undefined);
+                await session.detach().catch(() => undefined);
+            }));
         }
     }
 }
 class PlaywrightBrowserClient {
     options;
     browser = null;
+    parsedProxy;
+    proxyParsed = false;
     engine = "playwright-stealth";
     constructor(options = {}) {
         this.options = options;
@@ -402,13 +704,17 @@ class PlaywrightBrowserClient {
             return this.browser;
         }
         const chromium = await loadChromiumLauncher(this.options);
-        this.browser = await chromium.launch(toLaunchOptions(this.options));
+        if (!this.proxyParsed) {
+            this.parsedProxy = toPlaywrightProxy(this.options.proxy);
+            this.proxyParsed = true;
+        }
+        this.browser = await chromium.launch(toLaunchOptions(this.options, this.parsedProxy));
         return this.browser;
     }
     async newPage() {
         const browser = await this.ensureBrowser();
         const page = await browser.newPage();
-        return new PlaywrightBrowserPage(page);
+        return new PlaywrightBrowserPage(page, this.parsedProxy);
     }
     async rawPage() {
         throw new ProviderError("ctx.browser.rawPage() requires a CDP pool", {
@@ -418,9 +724,9 @@ class PlaywrightBrowserClient {
     }
     async withIsolatedContext(handler) {
         const browser = await this.ensureBrowser();
-        const context = await browser.newContext();
+        const context = await browser.newContext({ serviceWorkers: this.options.serviceWorkers });
         const page = await context.newPage();
-        const browserPage = new PlaywrightBrowserPage(page);
+        const browserPage = new PlaywrightBrowserPage(page, this.parsedProxy);
         try {
             return await handler(browserPage);
         }
@@ -457,7 +763,7 @@ function normalizeWebSocketEndpoint(endpoint) {
     }
     throw new Error(`Unsupported WebSocket endpoint protocol: ${url.protocol}`);
 }
-class JsonRpcWebSocketClient {
+class WebSocketCommandClient {
     nextId = 1;
     endpoint;
     listeners = new Map();
@@ -483,12 +789,7 @@ class JsonRpcWebSocketClient {
         const id = this.nextId++;
         return await new Promise((resolve, reject) => {
             this.pending.set(id, { resolve, reject });
-            socket.send(JSON.stringify({
-                id,
-                jsonrpc: "2.0",
-                method,
-                params,
-            }));
+            socket.send(JSON.stringify(this.createCommandFrame(id, method, params)));
         });
     }
     async close() {
@@ -526,7 +827,11 @@ class JsonRpcWebSocketClient {
                     }
                     this.pending.delete(payload.id);
                     if (payload.error) {
-                        pending.reject(new Error(payload.error.message ?? "JSON-RPC command failed"));
+                        const error = new Error(payload.error.message ?? "JSON-RPC command failed");
+                        if (typeof payload.error.code === "number") {
+                            Object.assign(error, { code: payload.error.code });
+                        }
+                        pending.reject(error);
                         return;
                     }
                     pending.resolve(payload.result ?? {});
@@ -554,6 +859,26 @@ class JsonRpcWebSocketClient {
         return this.socketPromise;
     }
 }
+class CdpWebSocketClient extends WebSocketCommandClient {
+    sessionId;
+    constructor(endpoint, sessionId) {
+        super(endpoint);
+        this.sessionId = sessionId;
+    }
+    createCommandFrame(id, method, params) {
+        return {
+            id,
+            method,
+            params,
+            ...(this.sessionId === undefined ? {} : { sessionId: this.sessionId }),
+        };
+    }
+}
+class JsonRpcWebSocketClient extends WebSocketCommandClient {
+    createCommandFrame(id, method, params) {
+        return { id, jsonrpc: "2.0", method, params };
+    }
+}
 function flattenCdpFrameTree(node, out = []) {
     if (!node) {
         return out;
@@ -567,6 +892,48 @@ function flattenCdpFrameTree(node, out = []) {
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isBrowserCookieSameSite(value) {
+    return value === "Strict" || value === "Lax" || value === "None";
+}
+function toBrowserCookie(cookie) {
+    return {
+        name: cookie.name,
+        value: cookie.value,
+        domain: cookie.domain,
+        path: cookie.path,
+        ...(cookie.expires !== undefined && cookie.expires > 0 ? { expires: cookie.expires } : {}),
+        httpOnly: cookie.httpOnly,
+        secure: cookie.secure,
+        ...(isBrowserCookieSameSite(cookie.sameSite) ? { sameSite: cookie.sameSite } : {}),
+    };
+}
+function parseCdpCookies(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("CDP Network.getCookies returned an invalid cookie list");
+    }
+    return value.map((cookie) => {
+        if (!isRecord(cookie) ||
+            typeof cookie.name !== "string" ||
+            typeof cookie.value !== "string" ||
+            typeof cookie.domain !== "string" ||
+            typeof cookie.path !== "string" ||
+            typeof cookie.expires !== "number" ||
+            typeof cookie.httpOnly !== "boolean" ||
+            typeof cookie.secure !== "boolean") {
+            throw new Error("CDP Network.getCookies returned an invalid cookie");
+        }
+        return toBrowserCookie({
+            name: cookie.name,
+            value: cookie.value,
+            domain: cookie.domain,
+            path: cookie.path,
+            expires: cookie.expires,
+            httpOnly: cookie.httpOnly,
+            secure: cookie.secure,
+            sameSite: cookie.sameSite,
+        });
+    });
+}
 function parsePoolAcquireResponse(value) {
     if (!isRecord(value) ||
         typeof value.pageId !== "string" ||
@@ -620,6 +987,17 @@ function getCdpExecutionContext(params) {
         id: typeof contextId === "number" ? contextId : undefined,
     };
 }
+function getCdpDestroyedExecutionContextId(params) {
+    if (!isRecord(params)) {
+        return undefined;
+    }
+    return typeof params.executionContextId === "number"
+        ? params.executionContextId
+        : undefined;
+}
+function isMissingExecutionContextError(error) {
+    return error instanceof Error && /\b(?:cannot|failed to) find context\b/i.test(error.message);
+}
 class CdpBrowserLocator {
     frame;
     selector;
@@ -723,16 +1101,22 @@ class CdpPoolBrowserPage {
     get id() {
         return this.pageId;
     }
-    async goto(url) {
+    async goto(url, options) {
         await this.initialize();
         const startedAt = Date.now();
-        let loadEventSeen = false;
-        const unsubscribe = this.pageClient.on("Page.loadEventFired", () => {
-            loadEventSeen = true;
+        const timeout = options?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const waitUntil = options?.waitUntil ?? "load";
+        let expectedEventSeen = false;
+        const eventName = waitUntil === "domcontentloaded" ? "Page.domContentEventFired" : "Page.loadEventFired";
+        const unsubscribe = this.pageClient.on(eventName, () => {
+            expectedEventSeen = true;
         });
         try {
-            await this.pageClient.send("Page.navigate", { url });
-            await this.waitForDocumentReady(startedAt + DEFAULT_WAIT_TIMEOUT_MS, () => loadEventSeen);
+            const navigation = (await this.pageClient.send("Page.navigate", { url }));
+            if (typeof navigation.errorText === "string" && navigation.errorText.length > 0) {
+                throw new Error(`Page.navigate failed: ${navigation.errorText} at ${url}`);
+            }
+            await this.waitForDocumentReady(startedAt + timeout, () => expectedEventSeen, waitUntil);
         }
         finally {
             unsubscribe();
@@ -742,10 +1126,25 @@ class CdpPoolBrowserPage {
         await this.initialize();
         return await this.evaluateWithContext(fn);
     }
+    async userAgent() {
+        return await this.evaluate("navigator.userAgent");
+    }
     async evaluateInFrame(frameId, fn) {
         await this.initialize();
         const contextId = await this.getFrameExecutionContextId(frameId);
-        return await this.evaluateWithContext(fn, contextId);
+        try {
+            return await this.evaluateWithContext(fn, contextId);
+        }
+        catch (error) {
+            if (!isMissingExecutionContextError(error)) {
+                throw error;
+            }
+            if (this.frameExecutionContexts.get(frameId) === contextId) {
+                this.frameExecutionContexts.delete(frameId);
+            }
+            const refreshedContextId = await this.getFrameExecutionContextId(frameId);
+            return await this.evaluateWithContext(fn, refreshedContextId);
+        }
     }
     async waitForSelectorInFrame(frameId, selector, options) {
         const timeout = options?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
@@ -845,6 +1244,11 @@ class CdpPoolBrowserPage {
         });
         return Buffer.from(String(result.data ?? ""), "base64");
     }
+    async cookies() {
+        await this.initialize();
+        const result = await this.pageClient.send("Network.getCookies");
+        return parseCdpCookies(result.cookies);
+    }
     async close() {
         if (this.closed) {
             return;
@@ -868,7 +1272,7 @@ class CdpPoolBrowserPage {
         const unsubscribe = this.pageClient.on("Fetch.requestPaused", handlePausedRequest);
         try {
             await this.pageClient.send("Fetch.enable", {
-                patterns: [{ requestStage: "Request", urlPattern: "*" }],
+                patterns: resourcePolicyFetchPatterns(policy),
             });
         }
         catch (error) {
@@ -893,6 +1297,24 @@ class CdpPoolBrowserPage {
             return;
         }
         try {
+            if (isCdpResponseStage(params) && policy.documentContentSecurityPolicy) {
+                const response = toCdpPausedDocumentResponse(params);
+                if (!response)
+                    throw new Error("CDP document response metadata is unavailable");
+                if (!response.hasBody) {
+                    await this.pageClient.send("Fetch.continueResponse", {
+                        requestId,
+                        responseCode: response.responseCode,
+                        responseHeaders: [...response.responseHeaders],
+                    });
+                    return;
+                }
+                const body = await this.pageClient.send("Fetch.getResponseBody", {
+                    requestId: response.requestId,
+                });
+                await this.pageClient.send("Fetch.fulfillRequest", toCdpDocumentFulfillParams(response, body, policy.documentContentSecurityPolicy));
+                return;
+            }
             const parsed = toCdpResourceRequest(params);
             if (!parsed || !allowedMethods.has(parsed.request.method)) {
                 await this.failCdpResourceRequest(requestId);
@@ -904,6 +1326,11 @@ class CdpPoolBrowserPage {
                 }
                 const decision = await resourceRoute.handle(parsed.request);
                 switch (decision.action) {
+                    case "continue":
+                        await this.pageClient.send("Fetch.continueRequest", {
+                            requestId: parsed.requestId,
+                        });
+                        return;
                     case "fulfill":
                         await this.pageClient.send("Fetch.fulfillRequest", toCdpFulfillParams(parsed.requestId, decision));
                         return;
@@ -941,6 +1368,20 @@ class CdpPoolBrowserPage {
                 this.frameExecutionContexts.set(context.frameId, context.id);
             }
         });
+        this.pageClient.on("Runtime.executionContextDestroyed", (params) => {
+            const destroyedContextId = getCdpDestroyedExecutionContextId(params);
+            if (destroyedContextId === undefined) {
+                return;
+            }
+            for (const [frameId, contextId] of this.frameExecutionContexts) {
+                if (contextId === destroyedContextId) {
+                    this.frameExecutionContexts.delete(frameId);
+                }
+            }
+        });
+        this.pageClient.on("Runtime.executionContextsCleared", () => {
+            this.frameExecutionContexts.clear();
+        });
         await this.pageClient.send("Page.enable");
         await this.pageClient.send("Runtime.enable");
         this.initialized = true;
@@ -962,11 +1403,13 @@ class CdpPoolBrowserPage {
         this.frameExecutionContexts.set(frameId, contextId);
         return contextId;
     }
-    async waitForDocumentReady(deadline, isLoadEventSeen) {
+    async waitForDocumentReady(deadline, isExpectedEventSeen, waitUntil) {
         while (Date.now() < deadline) {
             const readyState = await this.evaluate("document.readyState");
-            if (readyState === "complete" || readyState === "interactive") {
-                if (isLoadEventSeen() || readyState === "complete") {
+            const documentReady = readyState === "complete" ||
+                (waitUntil === "domcontentloaded" && readyState === "interactive");
+            if (documentReady) {
+                if (isExpectedEventSeen() || readyState === "complete") {
                     return;
                 }
             }
@@ -996,7 +1439,7 @@ class CdpPoolBrowserClient {
             ...(this.allowedHosts.length > 0 ? { allowedHosts: this.allowedHosts } : {}),
             ...(options?.isolatedContext ? { isolationMode: "browserContext" } : {}),
         }));
-        const pageClient = new JsonRpcWebSocketClient(acquireResult.wsEndpoint);
+        const pageClient = new CdpWebSocketClient(acquireResult.wsEndpoint);
         const page = new CdpPoolBrowserPage(acquireResult.pageId, acquireResult.browserContextId, pageClient, async (request) => {
             await this.poolClient.send("release", request);
         });