@apifuse/provider-sdk 2.1.0-beta.6 → 2.1.0-beta.9

package/dist/runtime/browser.js

@@ -0,0 +1,1034 @@
+import { createRequire } from "node:module";
+import { ProviderError } from "../errors";
+const require = createRequire(import.meta.url);
+const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
+const SELECTOR_POLL_INTERVAL_MS = 100;
+function getDefaultCdpPoolUrl(env = process.env) {
+    return env.APIFUSE__CDP_POOL__URL;
+}
+async function importOptionalModule(moduleName) {
+    return (await import(moduleName));
+}
+function unwrapModuleDefault(module) {
+    if ("default" in module) {
+        const defaultExport = module.default;
+        if ((typeof defaultExport === "object" && defaultExport !== null) ||
+            typeof defaultExport === "function") {
+            return defaultExport;
+        }
+    }
+    return module;
+}
+function isModuleNotFoundError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const code = "code" in error ? error.code : undefined;
+    return (code === "MODULE_NOT_FOUND" ||
+        code === "ERR_MODULE_NOT_FOUND" ||
+        error.message.includes("Cannot find module") ||
+        error.message.includes("Cannot find package"));
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatExpression(fn) {
+    if (typeof fn === "string") {
+        return fn;
+    }
+    return `(${fn.toString()})()`;
+}
+function toLaunchOptions(options) {
+    return {
+        args: options.extraArgs,
+        executablePath: options.executablePath,
+        headless: options.headless ?? true,
+        proxy: options.proxy ? { server: options.proxy } : undefined,
+    };
+}
+class PlaywrightBrowserLocator {
+    locator;
+    constructor(locator) {
+        this.locator = locator;
+    }
+    async click() {
+        await this.locator.click();
+    }
+    async fill(text) {
+        await this.locator.fill(text);
+    }
+    async textContent() {
+        return await this.locator.textContent();
+    }
+    async waitFor(options) {
+        await this.locator.waitFor(options);
+    }
+}
+class PlaywrightBrowserFrame {
+    frame;
+    constructor(frame) {
+        this.frame = frame;
+    }
+    get id() {
+        return this.frame.name() || this.frame.url();
+    }
+    get name() {
+        const name = this.frame.name();
+        return name.length > 0 ? name : undefined;
+    }
+    get parentId() {
+        const parent = this.frame.parentFrame();
+        return parent ? parent.name() || parent.url() : undefined;
+    }
+    async url() {
+        return this.frame.url();
+    }
+    async title() {
+        return await this.frame.evaluate("document.title");
+    }
+    async content() {
+        return await this.frame.content();
+    }
+    async evaluate(fn) {
+        if (typeof fn === "string") {
+            return await this.frame.evaluate(fn);
+        }
+        return await this.frame.evaluate(fn);
+    }
+    locator(selector) {
+        return new PlaywrightBrowserLocator(this.frame.locator(selector));
+    }
+}
+async function loadPlaywright() {
+    try {
+        await importOptionalModule("playwright");
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            throw new ProviderError("Playwright is not installed", {
+                cause: error instanceof Error ? error : undefined,
+                fix: "Run: bun add playwright",
+            });
+        }
+        throw error;
+    }
+    try {
+        return unwrapModuleDefault(await importOptionalModule("playwright"));
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            throw new ProviderError("Playwright is not installed", {
+                cause: error instanceof Error ? error : undefined,
+                fix: "Run: bun add playwright",
+            });
+        }
+        throw error;
+    }
+}
+const playwrightExtraStealthLaunchers = new WeakSet();
+async function loadPlaywrightExtra() {
+    try {
+        require("playwright");
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            throw new ProviderError("Playwright is not installed", {
+                cause: error instanceof Error ? error : undefined,
+                fix: "Run: bun add playwright",
+            });
+        }
+        throw error;
+    }
+    try {
+        return unwrapModuleDefault(await importOptionalModule("playwright-extra"));
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            throw new ProviderError("playwright-extra is not installed", {
+                cause: error instanceof Error ? error : undefined,
+                fix: "Run: bun add playwright-extra puppeteer-extra-plugin-stealth",
+            });
+        }
+        throw error;
+    }
+}
+async function loadStealthPluginFactory() {
+    try {
+        return unwrapModuleDefault(await importOptionalModule("puppeteer-extra-plugin-stealth"));
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            throw new ProviderError("puppeteer-extra-plugin-stealth is not installed", {
+                cause: error instanceof Error ? error : undefined,
+                fix: "Run: bun add playwright-extra puppeteer-extra-plugin-stealth",
+            });
+        }
+        throw error;
+    }
+}
+async function loadChromiumLauncher(options) {
+    if (!(options.stealth ?? true)) {
+        return (await loadPlaywright()).chromium;
+    }
+    const playwrightExtra = await loadPlaywrightExtra();
+    if (!playwrightExtraStealthLaunchers.has(playwrightExtra.chromium)) {
+        const createStealthPlugin = await loadStealthPluginFactory();
+        playwrightExtra.chromium.use(createStealthPlugin());
+        playwrightExtraStealthLaunchers.add(playwrightExtra.chromium);
+    }
+    return playwrightExtra.chromium;
+}
+async function loadNodriver() {
+    try {
+        await importOptionalModule("nodriver");
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            throw new ProviderError("nodriver is not installed", {
+                cause: error instanceof Error ? error : undefined,
+                fix: "Run: pip install nodriver (Python) or bun add nodriver",
+            });
+        }
+        throw error;
+    }
+}
+async function loadSeleniumBase() {
+    try {
+        await importOptionalModule("seleniumbase");
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            throw new ProviderError("seleniumbase is not installed", {
+                cause: error instanceof Error ? error : undefined,
+                fix: "Run: pip install seleniumbase",
+            });
+        }
+        throw error;
+    }
+}
+class PlaywrightBrowserPage {
+    page;
+    id = "main";
+    pageId;
+    constructor(page) {
+        this.page = page;
+    }
+    async goto(url) {
+        await this.page.goto(url);
+    }
+    async evaluate(fn) {
+        if (typeof fn === "string") {
+            return await this.page.evaluate(fn);
+        }
+        return await this.page.evaluate(fn);
+    }
+    async waitForSelector(selector, options) {
+        await this.page.waitForSelector(selector, options);
+    }
+    async click(selector) {
+        await this.page.click(selector);
+    }
+    async type(selector, text) {
+        await this.page.locator(selector).fill("");
+        await this.page.type(selector, text);
+    }
+    async fill(selector, text) {
+        await this.page.fill(selector, text);
+    }
+    async frames() {
+        return this.page.frames().map((frame) => new PlaywrightBrowserFrame(frame));
+    }
+    locator(selector) {
+        return new PlaywrightBrowserLocator(this.page.locator(selector));
+    }
+    async title() {
+        return await this.page.title();
+    }
+    async url() {
+        return this.page.url();
+    }
+    async content() {
+        return await this.page.content();
+    }
+    async screenshot(options) {
+        return await this.page.screenshot(options);
+    }
+    async close() {
+        await this.page.close();
+    }
+}
+class PlaywrightBrowserClient {
+    options;
+    browser = null;
+    engine = "playwright-stealth";
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async ensureBrowser() {
+        if (this.browser?.isConnected()) {
+            return this.browser;
+        }
+        const chromium = await loadChromiumLauncher(this.options);
+        this.browser = await chromium.launch(toLaunchOptions(this.options));
+        return this.browser;
+    }
+    async newPage() {
+        const browser = await this.ensureBrowser();
+        const page = await browser.newPage();
+        return new PlaywrightBrowserPage(page);
+    }
+    async rawPage() {
+        throw new ProviderError("ctx.browser.rawPage() requires a CDP pool", {
+            code: "BROWSER_RUNTIME_UNSUPPORTED",
+            fix: "Set APIFUSE__CDP_POOL__URL and use the SDK CDP pool-backed browser runtime. Local Chromium launch is not allowed for rawPage().",
+        });
+    }
+    async withIsolatedContext(handler) {
+        const browser = await this.ensureBrowser();
+        const context = await browser.newContext();
+        const page = await context.newPage();
+        const browserPage = new PlaywrightBrowserPage(page);
+        try {
+            return await handler(browserPage);
+        }
+        finally {
+            try {
+                await browserPage.close();
+            }
+            finally {
+                await context.close();
+            }
+        }
+    }
+    async close() {
+        const browser = this.browser;
+        this.browser = null;
+        if (!browser) {
+            return;
+        }
+        await browser.close();
+    }
+}
+function normalizeWebSocketEndpoint(endpoint) {
+    const url = new URL(endpoint);
+    if (url.protocol === "http:") {
+        url.protocol = "ws:";
+        return url.toString();
+    }
+    if (url.protocol === "https:") {
+        url.protocol = "wss:";
+        return url.toString();
+    }
+    if (url.protocol === "ws:" || url.protocol === "wss:") {
+        return endpoint;
+    }
+    throw new Error(`Unsupported WebSocket endpoint protocol: ${url.protocol}`);
+}
+class JsonRpcWebSocketClient {
+    nextId = 1;
+    endpoint;
+    listeners = new Map();
+    pending = new Map();
+    socket;
+    socketPromise;
+    constructor(endpoint) {
+        this.endpoint = normalizeWebSocketEndpoint(endpoint);
+    }
+    on(method, listener) {
+        const listeners = this.listeners.get(method) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(method, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.listeners.delete(method);
+            }
+        };
+    }
+    async send(method, params = {}) {
+        const socket = await this.getSocket();
+        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,
+            }));
+        });
+    }
+    async close() {
+        for (const pending of this.pending.values()) {
+            pending.reject(new Error(`WebSocket closed: ${this.endpoint}`));
+        }
+        this.pending.clear();
+        this.listeners.clear();
+        this.socket?.close();
+        this.socket = undefined;
+        this.socketPromise = undefined;
+    }
+    async getSocket() {
+        if (this.socket?.readyState === WebSocket.OPEN) {
+            return this.socket;
+        }
+        if (this.socketPromise) {
+            return this.socketPromise;
+        }
+        this.socketPromise = new Promise((resolve, reject) => {
+            const socket = new WebSocket(this.endpoint);
+            socket.addEventListener("open", () => {
+                this.socket = socket;
+                resolve(socket);
+            });
+            socket.addEventListener("message", (event) => {
+                const rawData = typeof event.data === "string"
+                    ? event.data
+                    : Buffer.from(event.data).toString("utf8");
+                const payload = JSON.parse(rawData);
+                if (typeof payload.id === "number") {
+                    const pending = this.pending.get(payload.id);
+                    if (!pending) {
+                        return;
+                    }
+                    this.pending.delete(payload.id);
+                    if (payload.error) {
+                        pending.reject(new Error(payload.error.message ?? "JSON-RPC command failed"));
+                        return;
+                    }
+                    pending.resolve(payload.result ?? {});
+                    return;
+                }
+                if (!payload.method) {
+                    return;
+                }
+                for (const listener of this.listeners.get(payload.method) ?? []) {
+                    listener(payload.params);
+                }
+            });
+            socket.addEventListener("close", () => {
+                for (const pending of this.pending.values()) {
+                    pending.reject(new Error(`WebSocket closed: ${this.endpoint}`));
+                }
+                this.pending.clear();
+                this.socket = undefined;
+                this.socketPromise = undefined;
+            });
+            socket.addEventListener("error", () => {
+                reject(new Error(`Unable to connect to WebSocket endpoint: ${this.endpoint}`));
+            });
+        });
+        return this.socketPromise;
+    }
+}
+function flattenCdpFrameTree(node, out = []) {
+    if (!node) {
+        return out;
+    }
+    out.push(node.frame);
+    for (const child of node.childFrames ?? []) {
+        flattenCdpFrameTree(child, out);
+    }
+    return out;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parsePoolAcquireResponse(value) {
+    if (!isRecord(value) ||
+        typeof value.pageId !== "string" ||
+        typeof value.wsEndpoint !== "string") {
+        throw new ProviderError("CDP Pool returned an invalid acquire response", {
+            code: "BROWSER_RUNTIME_UNSUPPORTED",
+        });
+    }
+    if (value.browserContextId !== undefined &&
+        typeof value.browserContextId !== "string") {
+        throw new ProviderError("CDP Pool returned an invalid acquire response", {
+            code: "BROWSER_RUNTIME_UNSUPPORTED",
+        });
+    }
+    return {
+        ...(value.browserContextId
+            ? { browserContextId: value.browserContextId }
+            : {}),
+        pageId: value.pageId,
+        wsEndpoint: value.wsEndpoint,
+    };
+}
+function parseCdpFrameTreeNode(value) {
+    if (!isRecord(value) || !isRecord(value.frame)) {
+        return undefined;
+    }
+    const frameId = value.frame.id;
+    if (typeof frameId !== "string") {
+        return undefined;
+    }
+    const childFrames = Array.isArray(value.childFrames)
+        ? value.childFrames
+            .map(parseCdpFrameTreeNode)
+            .filter((child) => child !== undefined)
+        : undefined;
+    return {
+        frame: {
+            id: frameId,
+            name: typeof value.frame.name === "string" ? value.frame.name : undefined,
+            parentId: typeof value.frame.parentId === "string"
+                ? value.frame.parentId
+                : undefined,
+            url: typeof value.frame.url === "string" ? value.frame.url : undefined,
+        },
+        ...(childFrames ? { childFrames } : {}),
+    };
+}
+function getCdpExecutionContext(params) {
+    if (!isRecord(params) || !isRecord(params.context)) {
+        return {};
+    }
+    const contextId = params.context.id;
+    const auxData = params.context.auxData;
+    return {
+        frameId: isRecord(auxData) && typeof auxData.frameId === "string"
+            ? auxData.frameId
+            : undefined,
+        id: typeof contextId === "number" ? contextId : undefined,
+    };
+}
+class CdpBrowserLocator {
+    frame;
+    selector;
+    constructor(frame, selector) {
+        this.frame = frame;
+        this.selector = selector;
+    }
+    async click() {
+        await this.waitFor();
+        await this.frame.evaluate(`(() => {
+				const element = document.querySelector(${JSON.stringify(this.selector)});
+				if (!(element instanceof HTMLElement)) {
+					throw new Error(${JSON.stringify(`Selector not found: ${this.selector}`)});
+				}
+				element.click();
+			})()`);
+    }
+    async fill(text) {
+        await this.waitFor();
+        await this.frame.evaluate(`(() => {
+				const element = document.querySelector(${JSON.stringify(this.selector)});
+				if (!(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement)) {
+					throw new Error(${JSON.stringify(`Unsupported input target: ${this.selector}`)});
+				}
+				element.focus();
+				element.value = ${JSON.stringify(text)};
+				element.dispatchEvent(new Event("input", { bubbles: true }));
+				element.dispatchEvent(new Event("change", { bubbles: true }));
+			})()`);
+    }
+    async textContent() {
+        return await this.frame.evaluate(`document.querySelector(${JSON.stringify(this.selector)})?.textContent ?? null`);
+    }
+    async waitFor(options) {
+        if (this.frame.waitForSelector) {
+            await this.frame.waitForSelector(this.selector, options);
+            return;
+        }
+        const timeout = options?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const deadline = Date.now() + timeout;
+        while (Date.now() < deadline) {
+            const exists = await this.frame.evaluate(`Boolean(document.querySelector(${JSON.stringify(this.selector)}))`);
+            if (exists) {
+                return;
+            }
+            await delay(SELECTOR_POLL_INTERVAL_MS);
+        }
+        throw new Error(`Timed out waiting for selector: ${this.selector}`);
+    }
+}
+class CdpBrowserFrame {
+    id;
+    page;
+    initialUrl;
+    name;
+    parentId;
+    constructor(id, page, initialUrl = "", name, parentId) {
+        this.id = id;
+        this.page = page;
+        this.initialUrl = initialUrl;
+        this.name = name;
+        this.parentId = parentId;
+    }
+    async url() {
+        const evaluatedUrl = await this.evaluate("window.location.href");
+        return evaluatedUrl || this.initialUrl;
+    }
+    async title() {
+        return await this.evaluate("document.title");
+    }
+    async content() {
+        return await this.evaluate("document.documentElement.outerHTML");
+    }
+    async evaluate(fn) {
+        return await this.page.evaluateInFrame(this.id, fn);
+    }
+    locator(selector) {
+        return new CdpBrowserLocator(this, selector);
+    }
+    async waitForSelector(selector, options) {
+        await this.page.waitForSelectorInFrame(this.id, selector, options);
+    }
+    fallbackUrl() {
+        return this.initialUrl;
+    }
+}
+class CdpPoolBrowserPage {
+    pageId;
+    browserContextId;
+    pageClient;
+    release;
+    closed = false;
+    initialized = false;
+    frameExecutionContexts = new Map();
+    constructor(pageId, browserContextId, pageClient, release) {
+        this.pageId = pageId;
+        this.browserContextId = browserContextId;
+        this.pageClient = pageClient;
+        this.release = release;
+    }
+    get id() {
+        return this.pageId;
+    }
+    async goto(url) {
+        await this.initialize();
+        const startedAt = Date.now();
+        let loadEventSeen = false;
+        const unsubscribe = this.pageClient.on("Page.loadEventFired", () => {
+            loadEventSeen = true;
+        });
+        try {
+            await this.pageClient.send("Page.navigate", { url });
+            await this.waitForDocumentReady(startedAt + DEFAULT_WAIT_TIMEOUT_MS, () => loadEventSeen);
+        }
+        finally {
+            unsubscribe();
+        }
+    }
+    async evaluate(fn) {
+        await this.initialize();
+        return await this.evaluateWithContext(fn);
+    }
+    async evaluateInFrame(frameId, fn) {
+        await this.initialize();
+        const contextId = await this.getFrameExecutionContextId(frameId);
+        return await this.evaluateWithContext(fn, contextId);
+    }
+    async waitForSelectorInFrame(frameId, selector, options) {
+        const timeout = options?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const deadline = Date.now() + timeout;
+        while (Date.now() < deadline) {
+            const exists = await this.evaluateInFrame(frameId, `Boolean(document.querySelector(${JSON.stringify(selector)}))`);
+            if (exists) {
+                return;
+            }
+            await delay(SELECTOR_POLL_INTERVAL_MS);
+        }
+        throw new Error(`Timed out waiting for selector: ${selector}`);
+    }
+    async evaluateWithContext(fn, contextId) {
+        const result = await this.pageClient.send("Runtime.evaluate", {
+            awaitPromise: true,
+            ...(contextId === undefined ? {} : { contextId }),
+            expression: formatExpression(fn),
+            returnByValue: true,
+        });
+        if (result.exceptionDetails) {
+            throw new Error(String(result.exceptionDetails.text ??
+                "Browser evaluation failed"));
+        }
+        return result.result?.value;
+    }
+    async waitForSelector(selector, options) {
+        const timeout = options?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const deadline = Date.now() + timeout;
+        while (Date.now() < deadline) {
+            const exists = await this.evaluate(`Boolean(document.querySelector(${JSON.stringify(selector)}))`);
+            if (exists) {
+                return;
+            }
+            await delay(SELECTOR_POLL_INTERVAL_MS);
+        }
+        throw new Error(`Timed out waiting for selector: ${selector}`);
+    }
+    async click(selector) {
+        await this.waitForSelector(selector);
+        await this.evaluate(`(() => {
+				const element = document.querySelector(${JSON.stringify(selector)});
+				if (!(element instanceof HTMLElement)) {
+					throw new Error(${JSON.stringify(`Selector not found: ${selector}`)});
+				}
+				element.click();
+			})()`);
+    }
+    async type(selector, text) {
+        await this.fill(selector, text);
+    }
+    async fill(selector, text) {
+        await this.waitForSelector(selector);
+        await this.evaluate(`(() => {
+				const element = document.querySelector(${JSON.stringify(selector)});
+				if (!(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement)) {
+					throw new Error(${JSON.stringify(`Unsupported input target: ${selector}`)});
+				}
+				element.focus();
+				element.value = "";
+			})()`);
+        await this.pageClient.send("Input.insertText", { text });
+        await this.evaluate(`(() => {
+				const element = document.querySelector(${JSON.stringify(selector)});
+				if (!(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement)) {
+					throw new Error(${JSON.stringify(`Unsupported input target: ${selector}`)});
+				}
+				element.dispatchEvent(new Event("input", { bubbles: true }));
+				element.dispatchEvent(new Event("change", { bubbles: true }));
+			})()`);
+    }
+    async frames() {
+        await this.initialize();
+        const result = await this.pageClient.send("Page.getFrameTree");
+        const frames = flattenCdpFrameTree(parseCdpFrameTreeNode(result.frameTree));
+        return frames.map((frame) => new CdpBrowserFrame(frame.id, this, frame.url ?? "", frame.name, frame.parentId));
+    }
+    locator(selector) {
+        return new CdpBrowserLocator(this, selector);
+    }
+    async title() {
+        return await this.evaluate("document.title");
+    }
+    async url() {
+        const [mainFrame] = await this.frames();
+        const frameUrl = mainFrame instanceof CdpBrowserFrame ? mainFrame.fallbackUrl() : "";
+        return frameUrl || (await this.evaluate("window.location.href"));
+    }
+    async content() {
+        return await this.evaluate("document.documentElement.outerHTML");
+    }
+    async screenshot(options) {
+        await this.initialize();
+        const result = await this.pageClient.send("Page.captureScreenshot", {
+            captureBeyondViewport: options?.fullPage ?? false,
+            format: "png",
+            fromSurface: true,
+        });
+        return Buffer.from(String(result.data ?? ""), "base64");
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        try {
+            await this.release({
+                ...(this.browserContextId
+                    ? { browserContextId: this.browserContextId }
+                    : {}),
+                pageId: this.pageId,
+            });
+        }
+        finally {
+            await this.pageClient.close();
+        }
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.pageClient.on("Runtime.executionContextCreated", (params) => {
+            const context = getCdpExecutionContext(params);
+            if (context.frameId && context.id !== undefined) {
+                this.frameExecutionContexts.set(context.frameId, context.id);
+            }
+        });
+        await this.pageClient.send("Page.enable");
+        await this.pageClient.send("Runtime.enable");
+        this.initialized = true;
+    }
+    async getFrameExecutionContextId(frameId) {
+        const existing = this.frameExecutionContexts.get(frameId);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const result = await this.pageClient.send("Page.createIsolatedWorld", {
+            frameId,
+            grantUniveralAccess: true,
+            worldName: "apifuse-provider-sdk",
+        });
+        const contextId = result.executionContextId;
+        if (typeof contextId !== "number") {
+            throw new Error(`Unable to resolve execution context for frame: ${frameId}`);
+        }
+        this.frameExecutionContexts.set(frameId, contextId);
+        return contextId;
+    }
+    async waitForDocumentReady(deadline, isLoadEventSeen) {
+        while (Date.now() < deadline) {
+            const readyState = await this.evaluate("document.readyState");
+            if (readyState === "complete" || readyState === "interactive") {
+                if (isLoadEventSeen() || readyState === "complete") {
+                    return;
+                }
+            }
+            await delay(SELECTOR_POLL_INTERVAL_MS);
+        }
+        throw new Error("Timed out waiting for page load");
+    }
+}
+class CdpPoolBrowserClient {
+    allowedHosts;
+    poolClient;
+    engine = "playwright-stealth";
+    constructor(options) {
+        if (!options.cdpUrl) {
+            throw new ProviderError("CDP Pool URL is required", {
+                code: "BROWSER_RUNTIME_UNSUPPORTED",
+            });
+        }
+        this.allowedHosts = [...new Set(options.allowedHosts ?? [])];
+        this.poolClient = new JsonRpcWebSocketClient(options.cdpUrl);
+    }
+    async newPage() {
+        return await this.acquirePage({ isolatedContext: true });
+    }
+    async acquirePage(options) {
+        const acquireResult = parsePoolAcquireResponse(await this.poolClient.send("acquire", {
+            ...(this.allowedHosts.length > 0
+                ? { allowedHosts: this.allowedHosts }
+                : {}),
+            ...(options?.isolatedContext
+                ? { isolationMode: "browserContext" }
+                : {}),
+        }));
+        const pageClient = new JsonRpcWebSocketClient(acquireResult.wsEndpoint);
+        const page = new CdpPoolBrowserPage(acquireResult.pageId, acquireResult.browserContextId, pageClient, async (request) => {
+            await this.poolClient.send("release", request);
+        });
+        try {
+            await page.evaluate(`window.navigator.webdriver === true ? Object.defineProperty(window.navigator, "webdriver", { configurable: true, get: () => undefined }) : undefined`);
+        }
+        catch (error) {
+            await page.close().catch(() => undefined);
+            throw error;
+        }
+        return page;
+    }
+    async rawPage() {
+        return await this.newPage();
+    }
+    async withIsolatedContext(handler) {
+        const page = await this.acquirePage({ isolatedContext: true });
+        try {
+            return await handler(page);
+        }
+        finally {
+            await page.close();
+        }
+    }
+    async close() {
+        await this.poolClient.close();
+    }
+}
+class UnsupportedBrowserEngineClient {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async newPage() {
+        if (this.engine === "nodriver") {
+            await loadNodriver();
+            throw new ProviderError("nodriver engine requires Python runtime", {
+                fix: "Use provider language: python and ctx.browser in Python",
+            });
+        }
+        await loadSeleniumBase();
+        throw new ProviderError("selenium-uc engine requires Python runtime", {
+            fix: "Use provider language: python",
+        });
+    }
+    async rawPage() {
+        return await this.newPage();
+    }
+    async withIsolatedContext() {
+        return await this.newPage();
+    }
+    async close() { }
+}
+function createPlaywrightStealthClient(options = {}) {
+    return new PlaywrightBrowserClient(options);
+}
+function createCdpPoolBrowserClient(options) {
+    return new CdpPoolBrowserClient(options);
+}
+function createNodriverClient() {
+    return new UnsupportedBrowserEngineClient("nodriver");
+}
+function createSeleniumUCClient() {
+    return new UnsupportedBrowserEngineClient("selenium-uc");
+}
+export class BrowserClient {
+    client;
+    cdpUrl;
+    activePage;
+    activePages = new Set();
+    _engine;
+    constructor(options = {}) {
+        const resolvedOptions = {
+            ...options,
+            cdpUrl: options.cdpUrl ?? getDefaultCdpPoolUrl(),
+        };
+        const engine = resolvedOptions.engine ?? "playwright-stealth";
+        this._engine = engine;
+        this.cdpUrl = resolvedOptions.cdpUrl;
+        if (resolvedOptions.requireCdpPool && !resolvedOptions.cdpUrl) {
+            throw new ProviderError("Managed CDP Pool is required for browser providers in production", {
+                code: "BROWSER_CDP_POOL_REQUIRED",
+                fix: "Set APIFUSE__CDP_POOL__URL for deployed browser providers. Local standalone development may omit it.",
+            });
+        }
+        switch (engine) {
+            case "nodriver":
+                this.client = createNodriverClient();
+                break;
+            case "selenium-uc":
+                this.client = createSeleniumUCClient();
+                break;
+            default:
+                this.client = resolvedOptions.cdpUrl
+                    ? createCdpPoolBrowserClient(resolvedOptions)
+                    : createPlaywrightStealthClient(resolvedOptions);
+        }
+    }
+    get engine() {
+        return this._engine;
+    }
+    async newPage() {
+        const page = await this.client.newPage();
+        return this.activatePage(page);
+    }
+    async rawPage() {
+        if (!this.cdpUrl) {
+            throw new ProviderError("ctx.browser.rawPage() requires a CDP pool", {
+                code: "BROWSER_RUNTIME_UNSUPPORTED",
+                fix: "Set APIFUSE__CDP_POOL__URL. The SDK escape hatch is CDP pool-backed only and never launches local Chromium.",
+            });
+        }
+        const page = await this.client.rawPage();
+        return this.activatePage(page);
+    }
+    async withIsolatedContext(handler) {
+        const previousActivePage = this.activePage;
+        let trackedPage;
+        return await this.client.withIsolatedContext(async (page) => {
+            trackedPage = this.activatePage(page);
+            try {
+                return await handler(trackedPage);
+            }
+            finally {
+                this.activePages.delete(trackedPage);
+                if (this.activePage === trackedPage) {
+                    this.activePage = previousActivePage;
+                }
+            }
+        });
+    }
+    activatePage(page) {
+        let closed = false;
+        const originalClose = page.close.bind(page);
+        const trackedPage = new Proxy(page, {
+            get: (target, property, receiver) => {
+                if (property === "close") {
+                    return async () => {
+                        if (closed)
+                            return;
+                        closed = true;
+                        try {
+                            await originalClose();
+                        }
+                        finally {
+                            this.activePages.delete(trackedPage);
+                            if (this.activePage === trackedPage) {
+                                this.activePage = undefined;
+                            }
+                        }
+                    };
+                }
+                const value = Reflect.get(target, property, receiver);
+                return typeof value === "function" ? value.bind(target) : value;
+            },
+        });
+        this.activePages.add(trackedPage);
+        this.activePage = trackedPage;
+        return trackedPage;
+    }
+    async solveChallenge(request) {
+        if (request.type !== "recaptcha") {
+            throw new ProviderError(`Unsupported browser challenge: ${request.type}`, {
+                code: "BROWSER_RUNTIME_UNSUPPORTED",
+            });
+        }
+        if (this.activePage) {
+            return await solveRecaptchaChallenge(this.activePage, request);
+        }
+        const page = await this.client.newPage();
+        try {
+            return await solveRecaptchaChallenge(page, request);
+        }
+        finally {
+            if (this.activePage === page) {
+                this.activePage = undefined;
+            }
+            await page.close();
+        }
+    }
+    async close() {
+        const pages = Array.from(this.activePages);
+        this.activePages.clear();
+        this.activePage = undefined;
+        try {
+            await Promise.all(pages.map((page) => page.close()));
+        }
+        finally {
+            await this.client.close();
+        }
+    }
+}
+async function solveRecaptchaChallenge(page, request) {
+    const timeout = request.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        const frames = await page.frames();
+        const recaptchaFrame = await findRecaptchaFrame(frames, request.siteKey);
+        if (recaptchaFrame) {
+            await recaptchaFrame.locator("#recaptcha-anchor").click();
+            return {
+                type: "recaptcha",
+                solved: true,
+                frameUrl: await recaptchaFrame.url(),
+            };
+        }
+        await delay(SELECTOR_POLL_INTERVAL_MS);
+    }
+    throw new Error("Timed out waiting for reCAPTCHA iframe");
+}
+async function findRecaptchaFrame(frames, siteKey) {
+    for (const frame of frames) {
+        const url = await frame.url();
+        const matchesRecaptcha = url.includes("google.com/recaptcha") ||
+            url.includes("recaptcha.net/recaptcha");
+        const matchesSiteKey = !siteKey || url.includes(siteKey);
+        if (matchesRecaptcha && matchesSiteKey) {
+            return frame;
+        }
+    }
+    return undefined;
+}
+export function createBrowserClient(options = {}) {
+    return new BrowserClient(options);
+}