@apifuse/provider-sdk 2.1.0-beta.9 → 2.2.0-beta.10

package/src/runtime/browser.ts

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
-import type { Frame, LaunchOptions, Locator, Page } from "playwright";
+import type { Frame, LaunchOptions, Locator, Page, Request, Route } from "playwright";
 
-import { ProviderError } from "../errors";
+import { ProviderError } from "../errors.js";
 import type {
 	BrowserChallengeRequest,
 	BrowserChallengeResult,
@@ -11,20 +11,25 @@ import type {
 	BrowserLocator,
 	BrowserOptions,
 	BrowserPage,
-} from "../types";
+	BrowserResourceBody,
+	BrowserResourceDecision,
+	BrowserResourceMethod,
+	BrowserResourcePolicy,
+	BrowserResourceRequest,
+} from "../types.js";
 
 const require = createRequire(import.meta.url);
 const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
 const SELECTOR_POLL_INTERVAL_MS = 100;
+const RESOURCE_POLICY_ROUTE_PATTERN = "**/*";
+const DEFAULT_RESOURCE_METHODS = ["GET", "HEAD"] as const;
 
 type PlaywrightModule = typeof import("playwright");
 type PlaywrightExtraModule = {
 	chromium: PlaywrightModule["chromium"] & { use(plugin: unknown): unknown };
 };
 
-type StealthPluginFactory = (options?: {
-	enabledEvasions?: Set<string>;
-}) => unknown;
+type StealthPluginFactory = (options?: { enabledEvasions?: Set<string> }) => unknown;
 
 type PoolAcquireResponse = {
 	browserContextId?: string;
@@ -62,8 +67,147 @@ type CdpFrameTreeNode = {
 	};
 };
 
+type CdpFetchFulfillParams = {
+	readonly requestId: string;
+	readonly responseCode: number;
+	readonly responseHeaders?: readonly {
+		readonly name: string;
+		readonly value: string;
+	}[];
+	readonly body?: string;
+};
+
 type BrowserPageContract = BrowserPage;
 
+function toResourceBody(body: BrowserResourceBody | undefined): Buffer | string | undefined {
+	if (body === undefined || typeof body === "string" || Buffer.isBuffer(body)) {
+		return body;
+	}
+
+	if (body instanceof ArrayBuffer) {
+		return Buffer.from(new Uint8Array(body));
+	}
+
+	return Buffer.from(body);
+}
+
+function isResourceMethod(method: string): method is BrowserResourceMethod {
+	return method === "GET" || method === "HEAD";
+}
+
+async function toResourceRequest(request: Request): Promise<BrowserResourceRequest | null> {
+	const method = request.method().toUpperCase();
+	if (!isResourceMethod(method)) {
+		return null;
+	}
+
+	return {
+		headers: await request.allHeaders(),
+		method,
+		resourceType: request.resourceType(),
+		url: request.url(),
+	};
+}
+
+function toCdpResourceRequest(
+	params: unknown,
+): { requestId: string; request: BrowserResourceRequest } | null {
+	if (!isRecord(params)) {
+		return null;
+	}
+
+	const requestId = params.requestId;
+	const rawRequest = params.request;
+	if (typeof requestId !== "string" || !isRecord(rawRequest)) {
+		return null;
+	}
+
+	const url = rawRequest.url;
+	const method = String(rawRequest.method ?? "").toUpperCase();
+	if (typeof url !== "string" || !isResourceMethod(method)) {
+		return null;
+	}
+
+	return {
+		requestId,
+		request: {
+			headers: toCdpResourceHeaders(rawRequest.headers),
+			method,
+			resourceType: typeof params.resourceType === "string" ? params.resourceType : undefined,
+			url,
+		},
+	};
+}
+
+function getCdpPausedRequestId(params: unknown): string | null {
+	if (!isRecord(params) || typeof params.requestId !== "string") {
+		return null;
+	}
+
+	return params.requestId;
+}
+
+function toCdpResourceHeaders(value: unknown): Record<string, string> {
+	if (!isRecord(value)) {
+		return {};
+	}
+
+	const headers: Record<string, string> = {};
+	for (const [name, headerValue] of Object.entries(value)) {
+		if (typeof headerValue === "string") {
+			headers[name] = headerValue;
+		}
+	}
+
+	return headers;
+}
+
+function matchesResourceRoute(
+	match: BrowserResourcePolicy["routes"][number]["match"],
+	request: BrowserResourceRequest,
+): boolean {
+	if (typeof match === "string") {
+		return request.url === match;
+	}
+	if (match instanceof RegExp) {
+		return match.test(request.url);
+	}
+
+	return match(request);
+}
+
+function toCdpFulfillParams(
+	requestId: string,
+	decision: Extract<BrowserResourceDecision, { readonly action: "fulfill" }>,
+): CdpFetchFulfillParams {
+	const body = toResourceBody(decision.body);
+	return {
+		...(body === undefined ? {} : { body: Buffer.from(body).toString("base64") }),
+		...(decision.headers === undefined
+			? {}
+			: {
+					responseHeaders: Object.entries(decision.headers).map(([name, value]) => ({
+						name,
+						value,
+					})),
+				}),
+		requestId,
+		responseCode: decision.status ?? 200,
+	};
+}
+
+async function fulfillResourceRoute(
+	route: Route,
+	decision: Extract<BrowserResourceDecision, { readonly action: "fulfill" }>,
+): Promise<void> {
+	const body = toResourceBody(decision.body);
+	await route.fulfill({
+		...(body === undefined ? {} : { body }),
+		...(decision.headers === undefined ? {} : { headers: decision.headers }),
+		status: decision.status ?? 200,
+	});
+}
+
 export type BrowserClientOptions = BrowserOptions & {
 	allowedHosts?: string[];
 	cdpUrl?: string;
@@ -76,18 +220,14 @@ type SupportedBrowserClient = {
 	close(): Promise<void>;
 	newPage(): Promise<BrowserPageContract>;
 	rawPage(): Promise<BrowserPageContract>;
-	withIsolatedContext<T>(
-		handler: (page: BrowserPageContract) => Promise<T>,
-	): Promise<T>;
+	withIsolatedContext<T>(handler: (page: BrowserPageContract) => Promise<T>): Promise<T>;
 };
 
 function getDefaultCdpPoolUrl(env = process.env): string | undefined {
 	return env.APIFUSE__CDP_POOL__URL;
 }
 
-async function importOptionalModule<T extends object>(
-	moduleName: string,
-): Promise<T> {
+async function importOptionalModule<T extends object>(moduleName: string): Promise<T> {
 	return (await import(moduleName)) as T;
 }
 
@@ -217,9 +357,7 @@ async function loadPlaywright(): Promise<PlaywrightModule> {
 	}
 
 	try {
-		return unwrapModuleDefault(
-			await importOptionalModule<PlaywrightModule>("playwright"),
-		);
+		return unwrapModuleDefault(await importOptionalModule<PlaywrightModule>("playwright"));
 	} catch (error) {
 		if (isModuleNotFoundError(error)) {
 			throw new ProviderError("Playwright is not installed", {
@@ -267,19 +405,14 @@ async function loadPlaywrightExtra(): Promise<PlaywrightExtraModule> {
 async function loadStealthPluginFactory(): Promise<StealthPluginFactory> {
 	try {
 		return unwrapModuleDefault(
-			await importOptionalModule<StealthPluginFactory>(
-				"puppeteer-extra-plugin-stealth",
-			),
+			await importOptionalModule<StealthPluginFactory>("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 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;
@@ -351,10 +484,7 @@ class PlaywrightBrowserPage implements BrowserPageContract {
 		return await this.page.evaluate(fn);
 	}
 
-	async waitForSelector(
-		selector: string,
-		options?: { timeout?: number },
-	): Promise<void> {
+	async waitForSelector(selector: string, options?: { timeout?: number }): Promise<void> {
 		await this.page.waitForSelector(selector, options);
 	}
 
@@ -398,6 +528,42 @@ class PlaywrightBrowserPage implements BrowserPageContract {
 	async close(): Promise<void> {
 		await this.page.close();
 	}
+
+	async withResourcePolicy<T>(policy: BrowserResourcePolicy, run: () => Promise<T>): Promise<T> {
+		const allowedMethods = new Set(policy.allowedMethods ?? DEFAULT_RESOURCE_METHODS);
+		const handler = async (route: Route): Promise<void> => {
+			const request = await toResourceRequest(route.request());
+			if (!request || !allowedMethods.has(request.method)) {
+				await route.abort("blockedbyclient");
+				return;
+			}
+
+			for (const resourceRoute of policy.routes) {
+				if (!matchesResourceRoute(resourceRoute.match, request)) {
+					continue;
+				}
+
+				const decision = await resourceRoute.handle(request);
+				switch (decision.action) {
+					case "fulfill":
+						await fulfillResourceRoute(route, decision);
+						return;
+					case "block":
+						await route.abort("blockedbyclient");
+						return;
+				}
+			}
+
+			await route.abort("blockedbyclient");
+		};
+
+		await this.page.route(RESOURCE_POLICY_ROUTE_PATTERN, handler);
+		try {
+			return await run();
+		} finally {
+			await this.page.unroute(RESOURCE_POLICY_ROUTE_PATTERN, handler);
+		}
+	}
 }
 
 class PlaywrightBrowserClient implements SupportedBrowserClient {
@@ -430,9 +596,7 @@ class PlaywrightBrowserClient implements SupportedBrowserClient {
 		});
 	}
 
-	async withIsolatedContext<T>(
-		handler: (page: BrowserPageContract) => Promise<T>,
-	): Promise<T> {
+	async withIsolatedContext<T>(handler: (page: BrowserPageContract) => Promise<T>): Promise<T> {
 		const browser = await this.ensureBrowser();
 		const context = await browser.newContext();
 		const page = await context.newPage();
@@ -480,10 +644,7 @@ function normalizeWebSocketEndpoint(endpoint: string): string {
 class JsonRpcWebSocketClient {
 	private nextId = 1;
 	private readonly endpoint: string;
-	private readonly listeners = new Map<
-		string,
-		Set<(params: unknown) => void>
-	>();
+	private readonly listeners = new Map<string, Set<(params: unknown) => void>>();
 	private readonly pending = new Map<
 		JsonRpcId,
 		{
@@ -577,9 +738,7 @@ class JsonRpcWebSocketClient {
 					this.pending.delete(payload.id);
 
 					if (payload.error) {
-						pending.reject(
-							new Error(payload.error.message ?? "JSON-RPC command failed"),
-						);
+						pending.reject(new Error(payload.error.message ?? "JSON-RPC command failed"));
 						return;
 					}
 
@@ -607,11 +766,7 @@ class JsonRpcWebSocketClient {
 			});
 
 			socket.addEventListener("error", () => {
-				reject(
-					new Error(
-						`Unable to connect to WebSocket endpoint: ${this.endpoint}`,
-					),
-				);
+				reject(new Error(`Unable to connect to WebSocket endpoint: ${this.endpoint}`));
 			});
 		});
 
@@ -650,19 +805,14 @@ function parsePoolAcquireResponse(value: unknown): PoolAcquireResponse {
 		});
 	}
 
-	if (
-		value.browserContextId !== undefined &&
-		typeof value.browserContextId !== "string"
-	) {
+	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 }
-			: {}),
+		...(value.browserContextId ? { browserContextId: value.browserContextId } : {}),
 		pageId: value.pageId,
 		wsEndpoint: value.wsEndpoint,
 	};
@@ -688,10 +838,7 @@ function parseCdpFrameTreeNode(value: unknown): CdpFrameTreeNode | undefined {
 		frame: {
 			id: frameId,
 			name: typeof value.frame.name === "string" ? value.frame.name : undefined,
-			parentId:
-				typeof value.frame.parentId === "string"
-					? value.frame.parentId
-					: undefined,
+			parentId: typeof value.frame.parentId === "string" ? value.frame.parentId : undefined,
 			url: typeof value.frame.url === "string" ? value.frame.url : undefined,
 		},
 		...(childFrames ? { childFrames } : {}),
@@ -709,10 +856,7 @@ function getCdpExecutionContext(params: unknown): {
 	const contextId = params.context.id;
 	const auxData = params.context.auxData;
 	return {
-		frameId:
-			isRecord(auxData) && typeof auxData.frameId === "string"
-				? auxData.frameId
-				: undefined,
+		frameId: isRecord(auxData) && typeof auxData.frameId === "string" ? auxData.frameId : undefined,
 		id: typeof contextId === "number" ? contextId : undefined,
 	};
 }
@@ -721,10 +865,7 @@ class CdpBrowserLocator implements BrowserLocator {
 	constructor(
 		private readonly frame: {
 			evaluate<T>(fn: string | (() => T)): Promise<T>;
-			waitForSelector?(
-				selector: string,
-				options?: { timeout?: number },
-			): Promise<void>;
+			waitForSelector?(selector: string, options?: { timeout?: number }): Promise<void>;
 		},
 		private readonly selector: string,
 	) {}
@@ -796,9 +937,7 @@ class CdpBrowserFrame implements BrowserFrame {
 	) {}
 
 	async url(): Promise<string> {
-		const evaluatedUrl = await this.evaluate<string | undefined>(
-			"window.location.href",
-		);
+		const evaluatedUrl = await this.evaluate<string | undefined>("window.location.href");
 		return evaluatedUrl || this.initialUrl;
 	}
 
@@ -818,10 +957,7 @@ class CdpBrowserFrame implements BrowserFrame {
 		return new CdpBrowserLocator(this, selector);
 	}
 
-	async waitForSelector(
-		selector: string,
-		options?: { timeout?: number },
-	): Promise<void> {
+	async waitForSelector(selector: string, options?: { timeout?: number }): Promise<void> {
 		await this.page.waitForSelectorInFrame(this.id, selector, options);
 	}
 
@@ -856,10 +992,7 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 
 		try {
 			await this.pageClient.send("Page.navigate", { url });
-			await this.waitForDocumentReady(
-				startedAt + DEFAULT_WAIT_TIMEOUT_MS,
-				() => loadEventSeen,
-			);
+			await this.waitForDocumentReady(startedAt + DEFAULT_WAIT_TIMEOUT_MS, () => loadEventSeen);
 		} finally {
 			unsubscribe();
 		}
@@ -870,10 +1003,7 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 		return await this.evaluateWithContext<T>(fn);
 	}
 
-	async evaluateInFrame<T>(
-		frameId: string,
-		fn: string | (() => T),
-	): Promise<T> {
+	async evaluateInFrame<T>(frameId: string, fn: string | (() => T)): Promise<T> {
 		await this.initialize();
 		const contextId = await this.getFrameExecutionContextId(frameId);
 		return await this.evaluateWithContext<T>(fn, contextId);
@@ -903,10 +1033,7 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 		throw new Error(`Timed out waiting for selector: ${selector}`);
 	}
 
-	private async evaluateWithContext<T>(
-		fn: string | (() => T),
-		contextId?: number,
-	): Promise<T> {
+	private async evaluateWithContext<T>(fn: string | (() => T), contextId?: number): Promise<T> {
 		const result = await this.pageClient.send("Runtime.evaluate", {
 			awaitPromise: true,
 			...(contextId === undefined ? {} : { contextId }),
@@ -916,20 +1043,14 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 
 		if (result.exceptionDetails) {
 			throw new Error(
-				String(
-					(result.exceptionDetails as { text?: string }).text ??
-						"Browser evaluation failed",
-				),
+				String((result.exceptionDetails as { text?: string }).text ?? "Browser evaluation failed"),
 			);
 		}
 
 		return (result.result as { value?: T } | undefined)?.value as T;
 	}
 
-	async waitForSelector(
-		selector: string,
-		options?: { timeout?: number },
-	): Promise<void> {
+	async waitForSelector(selector: string, options?: { timeout?: number }): Promise<void> {
 		const timeout = options?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
 		const deadline = Date.now() + timeout;
 
@@ -995,14 +1116,7 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 		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,
-				),
+			(frame) => new CdpBrowserFrame(frame.id, this, frame.url ?? "", frame.name, frame.parentId),
 		);
 	}
 
@@ -1016,8 +1130,7 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 
 	async url(): Promise<string> {
 		const [mainFrame] = await this.frames();
-		const frameUrl =
-			mainFrame instanceof CdpBrowserFrame ? mainFrame.fallbackUrl() : "";
+		const frameUrl = mainFrame instanceof CdpBrowserFrame ? mainFrame.fallbackUrl() : "";
 		return frameUrl || (await this.evaluate<string>("window.location.href"));
 	}
 
@@ -1045,9 +1158,7 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 
 		try {
 			await this.release({
-				...(this.browserContextId
-					? { browserContextId: this.browserContextId }
-					: {}),
+				...(this.browserContextId ? { browserContextId: this.browserContextId } : {}),
 				pageId: this.pageId,
 			});
 		} finally {
@@ -1055,6 +1166,93 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 		}
 	}
 
+	async withResourcePolicy<T>(policy: BrowserResourcePolicy, run: () => Promise<T>): Promise<T> {
+		const allowedMethods = new Set(policy.allowedMethods ?? DEFAULT_RESOURCE_METHODS);
+		const handlePausedRequest = (params: unknown): void => {
+			void this.handleResourcePolicyPausedRequest(params, policy, allowedMethods);
+		};
+
+		const unsubscribe = this.pageClient.on("Fetch.requestPaused", handlePausedRequest);
+
+		try {
+			await this.pageClient.send("Fetch.enable", {
+				patterns: [{ requestStage: "Request", urlPattern: "*" }],
+			});
+		} catch (error) {
+			unsubscribe();
+			throw new ProviderError(
+				"CDP browser target does not support BrowserPage.withResourcePolicy()",
+				{
+					cause: error instanceof Error ? error : undefined,
+					code: "BROWSER_RUNTIME_UNSUPPORTED",
+					fix: "Use a Chromium CDP target with the Fetch domain enabled, or use the local Playwright browser runtime.",
+				},
+			);
+		}
+
+		try {
+			return await run();
+		} finally {
+			unsubscribe();
+			await this.pageClient.send("Fetch.disable");
+		}
+	}
+
+	private async handleResourcePolicyPausedRequest(
+		params: unknown,
+		policy: BrowserResourcePolicy,
+		allowedMethods: ReadonlySet<BrowserResourceMethod>,
+	): Promise<void> {
+		const requestId = getCdpPausedRequestId(params);
+		if (requestId === null) {
+			return;
+		}
+
+		try {
+			const parsed = toCdpResourceRequest(params);
+			if (!parsed || !allowedMethods.has(parsed.request.method)) {
+				await this.failCdpResourceRequest(requestId);
+				return;
+			}
+
+			for (const resourceRoute of policy.routes) {
+				if (!matchesResourceRoute(resourceRoute.match, parsed.request)) {
+					continue;
+				}
+
+				const decision = await resourceRoute.handle(parsed.request);
+				switch (decision.action) {
+					case "fulfill":
+						await this.pageClient.send(
+							"Fetch.fulfillRequest",
+							toCdpFulfillParams(parsed.requestId, decision),
+						);
+						return;
+					case "block":
+						await this.failCdpResourceRequest(parsed.requestId);
+						return;
+				}
+			}
+
+			await this.failCdpResourceRequest(parsed.requestId);
+		} catch {
+			await this.failCdpResourceRequest(requestId);
+		}
+	}
+
+	private async failCdpResourceRequest(requestId: string): Promise<void> {
+		try {
+			await this.pageClient.send("Fetch.failRequest", {
+				errorReason: "BlockedByClient",
+				requestId,
+			});
+		} catch (error) {
+			if (error instanceof Error) {
+				return;
+			}
+		}
+	}
+
 	private async initialize(): Promise<void> {
 		if (this.initialized) {
 			return;
@@ -1084,9 +1282,7 @@ class CdpPoolBrowserPage implements BrowserPageContract {
 		});
 		const contextId = result.executionContextId;
 		if (typeof contextId !== "number") {
-			throw new Error(
-				`Unable to resolve execution context for frame: ${frameId}`,
-			);
+			throw new Error(`Unable to resolve execution context for frame: ${frameId}`);
 		}
 
 		this.frameExecutionContexts.set(frameId, contextId);
@@ -1132,17 +1328,11 @@ class CdpPoolBrowserClient implements SupportedBrowserClient {
 		return await this.acquirePage({ isolatedContext: true });
 	}
 
-	private async acquirePage(options?: {
-		isolatedContext?: boolean;
-	}): Promise<BrowserPageContract> {
+	private async acquirePage(options?: { isolatedContext?: boolean }): Promise<BrowserPageContract> {
 		const acquireResult = parsePoolAcquireResponse(
 			await this.poolClient.send("acquire", {
-				...(this.allowedHosts.length > 0
-					? { allowedHosts: this.allowedHosts }
-					: {}),
-				...(options?.isolatedContext
-					? { isolationMode: "browserContext" }
-					: {}),
+				...(this.allowedHosts.length > 0 ? { allowedHosts: this.allowedHosts } : {}),
+				...(options?.isolatedContext ? { isolationMode: "browserContext" } : {}),
 			}),
 		);
 		const pageClient = new JsonRpcWebSocketClient(acquireResult.wsEndpoint);
@@ -1171,9 +1361,7 @@ class CdpPoolBrowserClient implements SupportedBrowserClient {
 		return await this.newPage();
 	}
 
-	async withIsolatedContext<T>(
-		handler: (page: BrowserPageContract) => Promise<T>,
-	): Promise<T> {
+	async withIsolatedContext<T>(handler: (page: BrowserPageContract) => Promise<T>): Promise<T> {
 		const page = await this.acquirePage({ isolatedContext: true });
 
 		try {
@@ -1189,9 +1377,7 @@ class CdpPoolBrowserClient implements SupportedBrowserClient {
 }
 
 class UnsupportedBrowserEngineClient implements SupportedBrowserClient {
-	constructor(
-		readonly engine: Extract<BrowserEngine, "nodriver" | "selenium-uc">,
-	) {}
+	constructor(readonly engine: Extract<BrowserEngine, "nodriver" | "selenium-uc">) {}
 
 	async newPage(): Promise<never> {
 		if (this.engine === "nodriver") {
@@ -1218,15 +1404,11 @@ class UnsupportedBrowserEngineClient implements SupportedBrowserClient {
 	async close(): Promise<void> {}
 }
 
-function createPlaywrightStealthClient(
-	options: BrowserClientOptions = {},
-): SupportedBrowserClient {
+function createPlaywrightStealthClient(options: BrowserClientOptions = {}): SupportedBrowserClient {
 	return new PlaywrightBrowserClient(options);
 }
 
-function createCdpPoolBrowserClient(
-	options: BrowserClientOptions,
-): SupportedBrowserClient {
+function createCdpPoolBrowserClient(options: BrowserClientOptions): SupportedBrowserClient {
 	return new CdpPoolBrowserClient(options);
 }
 
@@ -1255,13 +1437,10 @@ export class BrowserClient implements BrowserClientContract {
 		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.",
-				},
-			);
+			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) {
@@ -1299,9 +1478,7 @@ export class BrowserClient implements BrowserClientContract {
 		return this.activatePage(page);
 	}
 
-	async withIsolatedContext<T>(
-		handler: (page: BrowserPageContract) => Promise<T>,
-	): Promise<T> {
+	async withIsolatedContext<T>(handler: (page: BrowserPageContract) => Promise<T>): Promise<T> {
 		const previousActivePage = this.activePage;
 		let trackedPage: BrowserPageContract | undefined;
 
@@ -1346,16 +1523,11 @@ export class BrowserClient implements BrowserClientContract {
 		return trackedPage;
 	}
 
-	async solveChallenge(
-		request: BrowserChallengeRequest,
-	): Promise<BrowserChallengeResult> {
+	async solveChallenge(request: BrowserChallengeRequest): Promise<BrowserChallengeResult> {
 		if (request.type !== "recaptcha") {
-			throw new ProviderError(
-				`Unsupported browser challenge: ${request.type}`,
-				{
-					code: "BROWSER_RUNTIME_UNSUPPORTED",
-				},
-			);
+			throw new ProviderError(`Unsupported browser challenge: ${request.type}`, {
+				code: "BROWSER_RUNTIME_UNSUPPORTED",
+			});
 		}
 
 		if (this.activePage) {
@@ -1417,8 +1589,7 @@ async function findRecaptchaFrame(
 	for (const frame of frames) {
 		const url = await frame.url();
 		const matchesRecaptcha =
-			url.includes("google.com/recaptcha") ||
-			url.includes("recaptcha.net/recaptcha");
+			url.includes("google.com/recaptcha") || url.includes("recaptcha.net/recaptcha");
 		const matchesSiteKey = !siteKey || url.includes(siteKey);
 		if (matchesRecaptcha && matchesSiteKey) {
 			return frame;
@@ -1428,8 +1599,6 @@ async function findRecaptchaFrame(
 	return undefined;
 }
 
-export function createBrowserClient(
-	options: BrowserClientOptions = {},
-): BrowserClient {
+export function createBrowserClient(options: BrowserClientOptions = {}): BrowserClient {
 	return new BrowserClient(options);
 }