surfsky 0.0.1

package/dist/index.js

@@ -0,0 +1,2754 @@
+import { z } from "zod";
+//#region src/browser/actions.ts
+function cdpParams(given) {
+	const params = {};
+	for (const [key, value] of Object.entries(given)) if (value !== void 0) params[key] = value;
+	return params;
+}
+var Keyboard = class {
+	#send;
+	constructor(send) {
+		this.#send = send;
+	}
+	type(text) {
+		return this.#send("Human.type", { text });
+	}
+	press(key, options = {}) {
+		return this.#send("Human.press", cdpParams({
+			key,
+			...options
+		}));
+	}
+};
+var Mouse = class {
+	#send;
+	constructor(send) {
+		this.#send = send;
+	}
+	move(x, y) {
+		return this.#send("Human.moveTo", {
+			x,
+			y
+		});
+	}
+	click(x, y, options = {}) {
+		return this.#send("Human.click", cdpParams({
+			x,
+			y,
+			...options
+		}));
+	}
+	down(x, y, options = {}) {
+		return this.#send("Human.mouseDown", cdpParams({
+			x,
+			y,
+			...options
+		}));
+	}
+	up(x, y, options = {}) {
+		return this.#send("Human.mouseUp", cdpParams({
+			x,
+			y,
+			...options
+		}));
+	}
+	wheel(options = {}) {
+		return this.#send("Human.wheel", cdpParams({ ...options }));
+	}
+	drag(options) {
+		return this.#send("Human.drag", cdpParams({ ...options }));
+	}
+};
+var Actions = class {
+	keyboard;
+	mouse;
+	constructor() {
+		const send = (method, params) => this.send(method, params);
+		this.keyboard = new Keyboard(send);
+		this.mouse = new Mouse(send);
+	}
+	click(selector, options = {}) {
+		return this.send("Human.click", cdpParams({
+			selector,
+			...options
+		}));
+	}
+	dblclick(selector, options = {}) {
+		return this.send("Human.dblclick", cdpParams({
+			selector,
+			...options
+		}));
+	}
+	hover(selector, options = {}) {
+		return this.send("Human.moveTo", cdpParams({
+			selector,
+			...options
+		}));
+	}
+	async type(selector, text) {
+		await this.click(selector);
+		return this.keyboard.type(text);
+	}
+	async fill(selector, text) {
+		await this.click(selector, { clickCount: 3 });
+		return this.keyboard.type(text);
+	}
+	scroll(options = {}) {
+		return this.send("Human.scroll", cdpParams({ ...options }));
+	}
+	scrollIntoView(selector, options = {}) {
+		return this.send("Human.scrollIntoView", cdpParams({
+			selector,
+			...options
+		}));
+	}
+	scrollTo(options = {}) {
+		return this.send("Human.scrollTo", cdpParams({ ...options }));
+	}
+};
+//#endregion
+//#region src/errors.ts
+var SurfskyError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+/** No API token, or another unusable client setting. */
+var ConfigurationError = class extends SurfskyError {};
+/** A request that failed validation before it was sent. `cause` is the ZodError. */
+var ValidationError = class extends SurfskyError {
+	issues;
+	constructor(message, error) {
+		super(message, { cause: error });
+		this.issues = error.issues;
+	}
+};
+/** An error response from the API, or a request that never got one. */
+var APIError = class extends SurfskyError {
+	statusCode;
+	body;
+	code;
+	requestId;
+	headers;
+	retryAfter;
+	constructor(message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.statusCode = options.statusCode;
+		this.body = options.body;
+		this.code = errorCode$1(options.body);
+		this.requestId = options.requestId;
+		this.headers = options.headers;
+		this.retryAfter = options.retryAfter;
+	}
+	toString() {
+		if (this.statusCode === void 0) return this.message;
+		return `[${this.statusCode}] ${this.message}`;
+	}
+};
+function errorCode$1(body) {
+	if (typeof body === "object" && body !== null && "code" in body) {
+		const code = body.code;
+		return typeof code === "string" ? code : void 0;
+	}
+}
+/** The request never reached the API. */
+var APIConnectionError = class extends APIError {};
+/** No response within the timeout. */
+var APITimeoutError = class extends APIConnectionError {};
+/** 400 or 422. */
+var BadRequestError = class extends APIError {};
+/** 401, or a 422 that rejects the token header. */
+var AuthenticationError = class extends APIError {};
+/** 402. */
+var PaymentRequiredError = class extends APIError {};
+/** 403. */
+var ForbiddenError = class extends APIError {};
+/** 404. */
+var NotFoundError = class extends APIError {};
+/** 409. */
+var ConflictError = class extends APIError {};
+/** 429. `retryAfter` is the server's hint in ms. */
+var RateLimitError = class extends APIError {};
+/** 429 with `shared_traffic_limit_reached`. */
+var SharedTrafficLimitError = class extends APIError {};
+/** 429 with `premium_traffic_limit_reached`. */
+var PremiumTrafficLimitError = class extends APIError {};
+/** 429 with `monthly_session_limit_reached`. */
+var MonthlySessionLimitError = class extends APIError {};
+/** 5xx. */
+var ServerError = class extends APIError {};
+/** An error reply to a CDP command, or a lost connection. */
+var CDPError = class extends SurfskyError {
+	code;
+	constructor(message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.code = options.code;
+	}
+};
+/** A browser wait or command ran out of time. */
+var BrowserTimeoutError = class extends SurfskyError {};
+/** The page is gone. */
+var PageClosedError = class extends SurfskyError {};
+//#endregion
+//#region src/util.ts
+/** Resolve after `ms`, or right away once `signal` aborts. */
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) return resolve();
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		function onAbort() {
+			clearTimeout(timer);
+			resolve();
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/** Race a promise against a deadline; the timer is cleared either way. */
+async function withTimeout(promise, ms, onTimeout) {
+	if (ms === null || ms === void 0) return promise;
+	let timer;
+	const deadline = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(onTimeout()), ms);
+	});
+	try {
+		return await Promise.race([promise, deadline]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** A one-shot event: `wait()` resolves once `set()` was called. */
+var Flag = class {
+	#resolvers = Promise.withResolvers();
+	#set = false;
+	get isSet() {
+		return this.#set;
+	}
+	set() {
+		if (this.#set) return;
+		this.#set = true;
+		this.#resolvers.resolve();
+	}
+	wait() {
+		return this.#resolvers.promise;
+	}
+};
+/** Drop `undefined` and `null` values, recursively: what pydantic's `exclude_none` did. */
+function dropNulls(value) {
+	if (Array.isArray(value)) return value.map(dropNulls);
+	if (typeof value !== "object" || value === null) return value;
+	if (value instanceof Blob || value instanceof FormData) return value;
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0 && item !== null).map(([key, item]) => [key, dropNulls(item)]));
+}
+function fromBase64(text) {
+	if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(text, "base64"));
+	return Uint8Array.from(atob(text), (char) => char.charCodeAt(0));
+}
+//#endregion
+//#region src/types.ts
+z.enum([
+	"win",
+	"mac",
+	"android"
+]);
+z.enum(["x86", "arm"]);
+z.enum(["phone", "tablet"]);
+const waitUntil = z.enum([
+	"domcontentloaded",
+	"load",
+	"networkidle",
+	"commit"
+]);
+const proxyType = z.enum(["residential", "mobile"]);
+const profileOrdering = z.enum([
+	"created",
+	"-created",
+	"active",
+	"-active",
+	"title",
+	"-title"
+]);
+const regionalPool = z.enum([
+	"western",
+	"europe",
+	"westeurope",
+	"northamerica",
+	"southamerica",
+	"asia",
+	"centralasia",
+	"southasia",
+	"eastasia",
+	"sea",
+	"oceania",
+	"mena"
+]);
+const loose = () => z.string();
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const noise = z.looseObject({
+	webgl: z.boolean().nullish(),
+	canvas: z.boolean().nullish(),
+	audio: z.boolean().nullish(),
+	client_rects: z.boolean().nullish()
+});
+const mediaDevices = z.looseObject({
+	video_in: z.number().nullish(),
+	audio_out: z.number().nullish(),
+	audio_in: z.number().nullish()
+});
+const geolocation = z.looseObject({
+	latitude: z.number().nullish(),
+	longitude: z.number().nullish(),
+	accuracy: z.number().nullish()
+});
+const fingerprint = z.looseObject({
+	os: loose().nullish(),
+	os_arch: loose().nullish(),
+	os_version: z.string().nullish(),
+	device_model: z.string().nullish(),
+	device_type: loose().nullish(),
+	user_agent: z.string().nullish(),
+	cpu: z.number().nullish(),
+	ram: z.number().nullish(),
+	renderer: z.string().nullish(),
+	noise: noise.nullish(),
+	media_devices: mediaDevices.nullish(),
+	screen: z.string().nullish(),
+	languages: z.array(z.string()).nullish(),
+	timezone: z.string().nullish(),
+	geolocation: geolocation.nullish(),
+	dns: z.string().nullish()
+});
+const storageOptions = z.looseObject({
+	cookies: z.boolean().nullish(),
+	passwords: z.boolean().nullish(),
+	extensions: z.boolean().nullish(),
+	localstorage: z.boolean().nullish(),
+	history: z.boolean().nullish(),
+	bookmarks: z.boolean().nullish(),
+	serviceworkers: z.boolean().nullish()
+});
+const browserSettings = z.strictObject({
+	inactive_kill_timeout: z.number().int().optional(),
+	cache_enabled: z.boolean().optional(),
+	cache_key: z.string().optional()
+});
+const shared = z.strictObject({
+	tier: z.literal("shared"),
+	country: z.string().min(1).optional()
+});
+const premium = z.strictObject({
+	tier: z.literal("premium").optional(),
+	country: z.string().min(1).optional(),
+	region: z.string().min(1).optional(),
+	city: z.string().min(1).optional(),
+	type: proxyType.optional(),
+	pool: regionalPool.optional(),
+	asn: z.number().int().min(1).max(4294967295).optional(),
+	lat: z.number().min(-90).max(90).optional(),
+	lon: z.number().min(-180).max(180).optional(),
+	session_minutes: z.number().int().min(1).max(10080).optional(),
+	unique_ip: z.boolean().optional(),
+	keep_asn: z.boolean().optional(),
+	keep_ip: z.boolean().optional()
+}).superRefine((p, ctx) => {
+	const gps = p.lat !== void 0 || p.lon !== void 0;
+	const set = (v) => v !== void 0;
+	const geo = set(p.country) || set(p.region) || set(p.city) || set(p.asn);
+	if ([
+		set(p.pool),
+		gps,
+		geo
+	].filter(Boolean).length > 1) ctx.addIssue("'pool', 'lat'/'lon' and 'country'/'region'/'city'/'asn' are 3 separate targeting modes - use one!");
+	if (gps && (p.lat === void 0 || p.lon === void 0)) ctx.addIssue("'lat' and 'lon' must be sent together");
+	if (set(p.region) && !set(p.country)) ctx.addIssue("region targeting requires country");
+	if (set(p.city) && !set(p.region)) ctx.addIssue("city targeting requires region");
+	if (set(p.asn) && !set(p.country)) ctx.addIssue("asn targeting requires country");
+});
+const proxySelector = z.discriminatedUnion("tier", [shared, premium], { error: (issue) => issue.code === "invalid_union" ? "tier must be \"shared\" or \"premium\"" : void 0 });
+const proxyLike = z.custom().superRefine((value, ctx) => {
+	if (typeof value === "string") return;
+	const proto = isRecord(value) ? Object.getPrototypeOf(value) : null;
+	if (proto !== null && proto !== Object.prototype) {
+		ctx.addIssue("a proxy is a URL string or a plain selector object");
+		return;
+	}
+	for (const issue of proxySelector.safeParse(value).error?.issues ?? []) ctx.addIssue({ ...issue });
+});
+const domainRoute = z.strictObject({
+	proxy: z.string(),
+	domain: z.array(z.string()).optional(),
+	domain_suffix: z.array(z.string()).optional(),
+	domain_keyword: z.array(z.string()).optional(),
+	domain_regex: z.array(z.string()).optional()
+});
+const cookieInput = z.union([z.string(), z.array(z.record(z.string(), z.unknown()))], { error: "expected a cookie string or an array of cookie objects" });
+const oneTimeStartRequest = z.strictObject({
+	fingerprint: fingerprint.optional(),
+	proxy: proxyLike.nullish(),
+	browser_settings: browserSettings.optional(),
+	enable_chromedriver: z.boolean().optional(),
+	extensions: z.array(z.string()).max(5).optional(),
+	proxy_blacklist: z.array(z.string()).optional(),
+	domain_routes: z.array(domainRoute).optional(),
+	cookies: cookieInput.optional()
+});
+const oneTimeOnly = (field) => z.undefined({ error: `${field} applies to one-time sessions only` }).nullish();
+const profileStartRequest = oneTimeStartRequest.extend({
+	fingerprint: oneTimeOnly("fingerprint"),
+	cookies: oneTimeOnly("cookies")
+});
+const profileCreateRequest = z.strictObject({
+	title: z.string().min(1),
+	fingerprint,
+	description: z.string().optional(),
+	proxy: proxyLike.nullish(),
+	cookies: cookieInput.optional(),
+	storage_options: storageOptions.optional()
+});
+const profileUpdateRequest = z.strictObject({
+	title: z.string().optional(),
+	/** `null` clears it. */
+	description: z.string().nullish(),
+	proxy: proxyLike.nullish(),
+	fingerprint: fingerprint.transform(({ os, os_arch, os_version, device_model, device_type, ...rest }) => rest).optional(),
+	storage_options: storageOptions.nullish()
+});
+const listPageRequest = z.strictObject({
+	page: z.number().int().min(0).optional(),
+	page_len: z.number().int().min(1).optional(),
+	ordering: profileOrdering.optional()
+});
+const scrapeRequest = z.strictObject({
+	url: z.string(),
+	screenshot: z.boolean().optional(),
+	/** Seconds, 0-60. */
+	wait: z.number().min(0).max(60).optional(),
+	wait_until: waitUntil.optional(),
+	wait_for: z.string().optional(),
+	/** 0-3. */
+	human_actions: z.number().int().min(0).max(3).optional()
+});
+const parser = (schema, what) => (value) => {
+	const result = schema.safeParse(value);
+	if (result.success) return dropNulls(result.data);
+	throw new ValidationError(`${what}: ${z.prettifyError(result.error)}`, result.error);
+};
+const parseOneTimeStartRequest = parser(oneTimeStartRequest, "start_one_time");
+const parseProfileStartRequest = parser(profileStartRequest, "start");
+const parseProfileCreateRequest = parser(profileCreateRequest, "create");
+const parseProfileUpdateRequest = parser(profileUpdateRequest, "update");
+const parseScrapeRequest = parser(scrapeRequest, "scrape");
+const parseListPageRequest = parser(listPageRequest, "listPage");
+function parseProxyLike(value, what = "proxy") {
+	return parser(proxyLike, what)(value);
+}
+//#endregion
+//#region src/transport.ts
+const AUTH_HEADER = "X-Cloud-Api-Token";
+const MAX_BACKOFF = 3e4;
+const STATUS_ERRORS = {
+	400: BadRequestError,
+	401: AuthenticationError,
+	402: PaymentRequiredError,
+	403: ForbiddenError,
+	404: NotFoundError,
+	409: ConflictError,
+	422: BadRequestError,
+	429: RateLimitError
+};
+const QUOTA_ERRORS = {
+	shared_traffic_limit_reached: SharedTrafficLimitError,
+	premium_traffic_limit_reached: PremiumTrafficLimitError,
+	monthly_session_limit_reached: MonthlySessionLimitError
+};
+const PLAN_FULL = "parallel_browsers_limit_reached";
+const NO_RETRY_CODES = /* @__PURE__ */ new Set([...Object.keys(QUOTA_ERRORS), PLAN_FULL]);
+const IDEMPOTENT = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"PUT",
+	"DELETE",
+	"OPTIONS"
+]);
+const RETRY_STATUSES = /* @__PURE__ */ new Set([
+	500,
+	502,
+	503,
+	504
+]);
+const NEVER_SENT = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"ConnectionRefused",
+	"FailedToOpenSocket",
+	"DNSError"
+]);
+const noop = () => {};
+/** Warnings and errors go to the console unless told otherwise; `null` silences all. */
+function makeLogger(given) {
+	if (given === null) return {
+		debug: noop,
+		info: noop,
+		warn: noop,
+		error: noop
+	};
+	return {
+		debug: given?.debug ?? noop,
+		info: given?.info ?? noop,
+		warn: given?.warn ?? ((message) => console.warn(message)),
+		error: given?.error ?? ((message) => console.error(message))
+	};
+}
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function buildUrl(baseUrl, path, params) {
+	const url = new URL(baseUrl + path);
+	for (const [key, value] of Object.entries(params ?? {})) if (value !== void 0) url.searchParams.set(key, String(value));
+	return url.toString();
+}
+/** Send with retries. Throws only when no response ever came back. */
+async function send(spec, options) {
+	const method = spec.method.toUpperCase();
+	const url = buildUrl(options.baseUrl, spec.path, spec.params);
+	const idempotent = IDEMPOTENT.has(method);
+	const headers = { ...options.headers };
+	let body = spec.body;
+	if (spec.json !== void 0) {
+		body = JSON.stringify(spec.json);
+		headers["Content-Type"] = "application/json";
+	}
+	const timeout = spec.timeout ?? options.timeout;
+	const sleep = options.sleep ?? defaultSleep;
+	const random = options.random ?? Math.random;
+	for (let attempt = 0;; attempt++) {
+		let response;
+		let error;
+		try {
+			response = await options.fetch(url, {
+				method,
+				headers,
+				body,
+				signal: timeout > 0 ? AbortSignal.timeout(timeout) : void 0
+			});
+		} catch (err) {
+			error = err;
+		}
+		const last = attempt >= options.retries;
+		let delay;
+		if (response !== void 0) {
+			if (last || !await retryResponse(response, idempotent)) return response;
+			const hinted = retryAfterMs(response);
+			delay = hinted === void 0 ? backoffDelay(attempt, options.backoff, random) : Math.min(hinted, MAX_BACKOFF);
+			await response.body?.cancel();
+		} else {
+			if (last || !retryError(error, idempotent)) {
+				if (!isTransportError(error)) throw error;
+				throw networkError(spec.path, error);
+			}
+			delay = backoffDelay(attempt, options.backoff, random);
+		}
+		const got = response !== void 0 ? response.status : describe(error);
+		options.logger.warn(`${method} ${spec.path} -> ${got}, retry in ${(delay / 1e3).toFixed(1)}s`);
+		await sleep(delay);
+	}
+}
+function backoffDelay(attempt, backoff, random) {
+	return Math.min(backoff * 2 ** attempt, MAX_BACKOFF) + random() * backoff;
+}
+async function retryResponse(response, idempotent) {
+	if (response.status === 429) return !neverRetried(await parseBody(response.clone()));
+	return idempotent && RETRY_STATUSES.has(response.status);
+}
+function errorCode(error) {
+	if (!isRecord(error)) return void 0;
+	const cause = error.cause;
+	if (isRecord(cause) && typeof cause.code === "string") return cause.code;
+	return typeof error.code === "string" ? error.code : void 0;
+}
+const TIMEOUT_CODES = /* @__PURE__ */ new Set(["UND_ERR_CONNECT_TIMEOUT", "ConnectionTimeout"]);
+function isTimeout(error) {
+	if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) return true;
+	const code = errorCode(error);
+	return code !== void 0 && TIMEOUT_CODES.has(code);
+}
+/** A failure of the transport itself, as opposed to a bad argument thrown by fetch. */
+function isTransportError(error) {
+	if (isTimeout(error) || errorCode(error) !== void 0) return true;
+	return error instanceof TypeError && error.cause !== void 0;
+}
+function retryError(error, idempotent) {
+	const code = errorCode(error);
+	if (code !== void 0 && NEVER_SENT.has(code)) return true;
+	return idempotent && isTransportError(error);
+}
+function describe(error) {
+	return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+/** JSON when it parses, the text otherwise, `null` when empty. */
+async function parseBody(response) {
+	const text = await response.text();
+	if (!text) return null;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+/** Read a reply: map an error status, unwrap `{success, msg, data}`, parse. */
+async function result(spec, response) {
+	const status = response.status;
+	const body = await parseBody(response);
+	if (status >= 400 && !spec.acceptError?.(status, body)) throw apiError(spec.method, spec.path, response, body);
+	let data = body;
+	if (isRecord(body) && "data" in body) {
+		if (body.success === false && spec.acceptError === void 0) throw new APIError(String(body.msg || "request failed"), { body });
+		data = body.data;
+	}
+	try {
+		return spec.parse ? spec.parse(data) : data;
+	} catch (err) {
+		throw new APIError(`unexpected response from ${spec.method} ${spec.path}: ${describe(err)}`, {
+			statusCode: status,
+			body,
+			requestId: requestId(response),
+			headers: headersOf(response),
+			cause: err
+		});
+	}
+}
+function neverRetried(body) {
+	return isRecord(body) && typeof body.code === "string" && NO_RETRY_CODES.has(body.code);
+}
+/** The Retry-After header in ms: seconds or an HTTP date. */
+function retryAfterMs(response) {
+	const value = response.headers.get("Retry-After")?.trim();
+	if (!value) return void 0;
+	if (/^\d+$/.test(value)) return Number(value) * 1e3;
+	const when = Date.parse(value);
+	if (Number.isNaN(when)) return void 0;
+	return Math.max(0, when - Date.now());
+}
+function requestId(response) {
+	return response.headers.get("cf-ray") ?? void 0;
+}
+function headersOf(response) {
+	return Object.fromEntries(response.headers);
+}
+function tokenRejected(body) {
+	if (!isRecord(body) || !isRecord(body.data) || !Array.isArray(body.data.errors)) return false;
+	return body.data.errors.some((error) => isRecord(error) && Array.isArray(error.loc) && error.loc.some((part) => String(part).toLowerCase() === "X-Cloud-Api-Token".toLowerCase()));
+}
+/** Escape one path segment. An empty id would silently hit the list endpoint. */
+function ref(value) {
+	if (!value) throw new TypeError("an empty id would address a different endpoint");
+	if (value === "." || value === "..") throw new TypeError(`'${value}' is not a path segment`);
+	return encodeURIComponent(value);
+}
+function fieldErrors(details) {
+	if (Array.isArray(details)) return details.filter(isRecord).map((e) => `${(Array.isArray(e.loc) ? e.loc : []).map(String).join(".")}: ${e.msg}`).join("; ");
+	if (isRecord(details)) return Object.entries(details).map(([name, why]) => `${name}: ${why}`).join("; ");
+	return "";
+}
+function apiError(method, path, response, body) {
+	const status = response.status;
+	let message = `HTTP ${status}`;
+	if (isRecord(body)) {
+		message = String(body.msg || body.message || body.detail || body.error || message);
+		const fields = fieldErrors(isRecord(body.data) ? body.data.errors : body.errors);
+		if (fields) message += `: ${fields}`;
+	} else if (typeof body === "string" && body) message = body.slice(0, 500);
+	message = `${method.toUpperCase()} ${path}: ${message}`;
+	let error = STATUS_ERRORS[status] ?? (status >= 500 ? ServerError : APIError);
+	let retryAfter;
+	if (status === 422 && tokenRejected(body)) error = AuthenticationError;
+	if (status === 429) {
+		const code = isRecord(body) && typeof body.code === "string" ? body.code : "";
+		error = QUOTA_ERRORS[code] ?? RateLimitError;
+		if (error === RateLimitError) retryAfter = retryAfterMs(response);
+	}
+	return new error(message, {
+		statusCode: status,
+		body,
+		requestId: requestId(response),
+		headers: headersOf(response),
+		retryAfter
+	});
+}
+function networkError(path, error) {
+	if (isTimeout(error)) return new APITimeoutError(`request to ${path} timed out`, { cause: error });
+	return new APIConnectionError(`request to ${path} failed: ${describe(error)}`, { cause: error });
+}
+//#endregion
+//#region src/browser/cdp.ts
+/** A tiny Chrome DevTools Protocol client: JSON-RPC over a WebSocket. */
+const nativeWebSocket = (url) => new WebSocket(url);
+var CDPClient = class {
+	wsUrl;
+	onClose;
+	#create;
+	#logger;
+	#ws;
+	#closed = false;
+	#closeReported = false;
+	#nextId = 0;
+	#pending = /* @__PURE__ */ new Map();
+	#handlers = /* @__PURE__ */ new Map();
+	constructor(wsUrl, options = {}) {
+		this.wsUrl = wsUrl;
+		this.onClose = options.onClose;
+		this.#create = options.createWebSocket ?? nativeWebSocket;
+		this.#logger = makeLogger(options.logger);
+	}
+	get connected() {
+		return this.#ws !== void 0 && !this.#closed;
+	}
+	async start() {
+		if (this.#ws !== void 0) throw new Error("CDP client is already started");
+		const ws = this.#create(this.wsUrl);
+		this.#ws = ws;
+		await new Promise((resolve, reject) => {
+			let opened = false;
+			ws.addEventListener("open", () => {
+				opened = true;
+				resolve();
+			});
+			ws.addEventListener("error", (event) => {
+				if (opened) return;
+				reject(new CDPError(`CDP connection failed: ${describeEvent(event)}`));
+			});
+			ws.addEventListener("close", (event) => {
+				if (!opened) reject(new CDPError(`CDP connection failed: ${describeEvent(event)}`));
+				this.#onSocketClose();
+			});
+			ws.addEventListener("message", (event) => this.#onMessage(event.data));
+		}).catch((err) => {
+			this.#closed = true;
+			this.#ws = void 0;
+			try {
+				ws.close();
+			} catch {}
+			throw err;
+		});
+	}
+	async stop() {
+		this.#closed = true;
+		const ws = this.#ws;
+		this.#ws = void 0;
+		if (ws !== void 0) try {
+			ws.close(1e3);
+		} catch {}
+		this.#failPending();
+		this.#reportClose();
+	}
+	on(event, handler) {
+		this.#handlers.set(event, handler);
+	}
+	/** Put a command on the wire and hand back its reply to await later. */
+	post(method, params, sessionId) {
+		if (this.#closed) throw new CDPError("CDP connection closed");
+		const ws = this.#ws;
+		if (ws === void 0) throw new Error("CDP client is not connected; call start() first");
+		this.#nextId += 1;
+		const id = this.#nextId;
+		const message = {
+			id,
+			method,
+			params: params ?? {}
+		};
+		if (sessionId !== void 0) message.sessionId = sessionId;
+		const reply = Promise.withResolvers();
+		reply.promise.catch(() => {});
+		this.#pending.set(id, reply);
+		try {
+			ws.send(JSON.stringify(message));
+		} catch (err) {
+			this.#pending.delete(id);
+			throw new CDPError(`CDP connection closed: ${describeEvent(err)}`, { cause: err });
+		}
+		return {
+			id,
+			reply: reply.promise
+		};
+	}
+	/** Drop a posted command nobody is going to await. */
+	forget(id) {
+		this.#pending.delete(id);
+	}
+	async send(method, params, sessionId) {
+		const { id, reply } = this.post(method, params, sessionId);
+		try {
+			return await reply;
+		} finally {
+			this.#pending.delete(id);
+		}
+	}
+	#onMessage(raw) {
+		if (typeof raw !== "string") {
+			this.#logger.warn("dropping a binary CDP frame");
+			return;
+		}
+		let message;
+		try {
+			message = JSON.parse(raw);
+		} catch {
+			this.#logger.warn("dropping unparsable CDP frame");
+			return;
+		}
+		if (isRecord(message)) this.#dispatch(message);
+	}
+	#dispatch(message) {
+		const id = message.id;
+		if (typeof id === "number") {
+			const reply = this.#pending.get(id);
+			this.#pending.delete(id);
+			if (reply === void 0) return;
+			const error = message.error;
+			if (isRecord(error)) {
+				let text = typeof error.message === "string" ? error.message : "CDP error";
+				if (error.data) text = `${text}: ${String(error.data)}`;
+				const code = typeof error.code === "number" ? error.code : void 0;
+				reply.reject(new CDPError(text, { code }));
+			} else reply.resolve(message.result ?? {});
+			return;
+		}
+		const method = typeof message.method === "string" ? message.method : "";
+		const handler = this.#handlers.get(method);
+		if (handler === void 0) return;
+		const sessionId = typeof message.sessionId === "string" ? message.sessionId : void 0;
+		try {
+			handler(message.params ?? {}, sessionId);
+		} catch (err) {
+			this.#logger.error(`CDP event handler for ${method} failed: ${describeEvent(err)}`);
+		}
+	}
+	#onSocketClose() {
+		if (!this.#closed) this.#logger.warn("CDP connection closed by the server");
+		this.#closed = true;
+		this.#ws = void 0;
+		this.#failPending();
+		this.#reportClose();
+	}
+	#reportClose() {
+		if (this.#closeReported) return;
+		this.#closeReported = true;
+		this.onClose?.();
+	}
+	#failPending() {
+		const pending = [...this.#pending.values()];
+		this.#pending.clear();
+		for (const reply of pending) reply.reject(new CDPError("CDP connection closed"));
+	}
+};
+function describeEvent(event) {
+	if (event instanceof Error) return event.message;
+	if (isRecord(event)) {
+		if (event.error instanceof Error) return event.error.message;
+		if (typeof event.message === "string") return event.message;
+		if (typeof event.reason === "string" && event.reason) return event.reason;
+		if (typeof event.code === "number") return `code ${event.code}`;
+	}
+	return String(event);
+}
+const LIFECYCLE_EVENT = {
+	commit: "commit",
+	domcontentloaded: "DOMContentLoaded",
+	load: "load",
+	networkidle: "networkIdle"
+};
+const WORLD_NAME = "utility";
+/** A dialog is answered after this long, as a person would. */
+const DIALOG_DELAY = [600, 1400];
+const FUNCTION = /^\s*(async\s+)?(function\b|\([^()]*\)\s*=>|[\w$]+\s*=>)/;
+const SELECT = `(selector, value, label) => {
+  const el = document.querySelector(selector);
+  if (!el) return null;
+  const option = Array.from(el.options).find(
+    o => label === null ? o.value === value : o.label === label || o.text === label
+  );
+  if (!option) return false;
+  el.value = option.value;
+  el.dispatchEvent(new Event("input", {bubbles: true}));
+  el.dispatchEvent(new Event("change", {bubbles: true}));
+  return option.value;
+}`;
+function cookieParam(cookie) {
+	const out = dropNulls(cookie);
+	const expires = out.expirationDate;
+	return expires === void 0 ? out : {
+		expires,
+		...out
+	};
+}
+function fromCdpCookie(raw) {
+	const { expires, ...rest } = raw;
+	return expires === void 0 ? rest : {
+		expirationDate: expires,
+		...rest
+	};
+}
+function commandFailed(method, params, err) {
+	const selector = params?.selector;
+	const where = typeof selector === "string" ? `${method} '${selector}'` : method;
+	if (err.message.includes("Could not find node with given id")) return new CDPError(`${where}: the page navigated while the command ran.`, {
+		code: err.code,
+		cause: err
+	});
+	return new CDPError(`${where}: ${err.message}`, {
+		code: err.code,
+		cause: err
+	});
+}
+/** A wait's time budget: poll loops `check()` it, single awaits `race()` against it. `null` is no limit. */
+var Deadline = class {
+	timeout;
+	message;
+	until;
+	constructor(timeout, message) {
+		this.timeout = timeout ?? null;
+		this.message = message;
+		this.until = this.timeout === null ? Number.POSITIVE_INFINITY : Date.now() + this.timeout;
+	}
+	error() {
+		return new BrowserTimeoutError(`${this.message} within ${this.timeout}ms`);
+	}
+	check() {
+		if (Date.now() >= this.until) throw this.error();
+	}
+	race(promise) {
+		if (this.timeout === null) return promise;
+		return withTimeout(promise, Math.max(0, this.until - Date.now()), () => this.error());
+	}
+};
+var CapturedResponse = class {
+	url;
+	status;
+	headers;
+	body;
+	constructor(url, status, headers, body) {
+		this.url = url;
+		this.status = status;
+		this.headers = headers;
+		this.body = body;
+	}
+	get text() {
+		return new TextDecoder().decode(this.body);
+	}
+	json() {
+		return JSON.parse(this.text);
+	}
+};
+/** The lifecycle wait of one `goto`. */
+var NavWaiter = class {
+	milestone;
+	done = new Flag();
+	error;
+	loaderId;
+	created = [];
+	reached = /* @__PURE__ */ new Set();
+	constructor(milestone) {
+		this.milestone = milestone;
+	}
+	follow(loaderId) {
+		let id = loaderId;
+		if (this.created.includes(id)) id = this.created[this.created.length - 1];
+		this.loaderId = id;
+		return this.reached.has(id);
+	}
+	followNewest() {
+		const newest = this.created[this.created.length - 1];
+		if (newest !== void 0) return this.follow(newest);
+		this.loaderId = "";
+		return false;
+	}
+	observe(name, loaderId) {
+		if (this.done.isSet || typeof loaderId !== "string" || !loaderId) return;
+		if (name === "init") {
+			if (this.loaderId === void 0) this.created.push(loaderId);
+			else if (loaderId !== this.loaderId) this.loaderId = loaderId;
+		} else if (name === this.milestone) {
+			if (this.loaderId === void 0) this.reached.add(loaderId);
+			else if (loaderId === this.loaderId) this.done.set();
+		}
+	}
+	fail(reason) {
+		this.error = reason;
+		this.done.set();
+	}
+};
+/** One page target. `Browser` is the session's first page plus the connection. */
+var Page = class extends Actions {
+	/** @internal */ _browser;
+	/** @internal */ _targetId;
+	/** @internal */ _sessionId;
+	/** @internal */ _frameId;
+	/** @internal */ _closed;
+	/** Answers this page's dialogs; the browser's handler when unset. */
+	onDialog = null;
+	/** @internal the main frame's newest document */
+	_loaderId;
+	/** @internal the lifecycle events it reached */
+	_milestones;
+	/** @internal the isolated world's context */
+	_worldId;
+	/** @internal commands wait for the setup */
+	_ready;
+	/** @internal */ _setupError;
+	/** @internal */ _waiter;
+	/** @internal */ _status;
+	/** @internal */ _storageReady;
+	/** @internal */ _captures;
+	/** @internal */ _responses;
+	/** @internal */ _inFlight;
+	constructor(browser, targetId, sessionId) {
+		super();
+		this._browser = browser ?? this;
+		this._reset(targetId, sessionId);
+	}
+	/** @internal fresh page state; the browser reuses it on connect */
+	_reset(targetId, sessionId) {
+		this._targetId = targetId;
+		this._sessionId = sessionId;
+		this._frameId = "";
+		this._closed = false;
+		this._loaderId = void 0;
+		this._milestones = /* @__PURE__ */ new Set();
+		this._worldId = void 0;
+		this._ready = new Flag();
+		this._ready.set();
+		this._setupError = void 0;
+		this._waiter = void 0;
+		this._status = void 0;
+		this._storageReady = false;
+		this._captures = [];
+		this._responses = [];
+		this._inFlight = /* @__PURE__ */ new Map();
+	}
+	get cdp() {
+		return this._browser.cdp;
+	}
+	get targetId() {
+		return this._targetId;
+	}
+	get closed() {
+		return this._closed;
+	}
+	get status() {
+		return this._status;
+	}
+	async send(method, params) {
+		this._requireOpen();
+		await this._waitReady();
+		return this._send(method, params);
+	}
+	/** @internal */
+	_requireOpen() {
+		if (this._closed) throw new PageClosedError("page is closed");
+	}
+	/** @internal */
+	async _send(method, params) {
+		const timeout = this._browser.commandTimeout;
+		try {
+			return await withTimeout(this.cdp.send(method, params, this._sessionId), timeout, () => new BrowserTimeoutError(`${method} did not answer within ${timeout}ms`));
+		} catch (err) {
+			if (err instanceof CDPError) throw commandFailed(method, params, err);
+			throw err;
+		}
+	}
+	/** @internal */
+	async _waitReady() {
+		await this._ready.wait();
+		if (this._setupError !== void 0) throw this._setupError;
+	}
+	/** @internal */
+	async _setup(waiting) {
+		const commands = [
+			["Page.enable", void 0],
+			["Page.setLifecycleEventsEnabled", { enabled: true }],
+			["Fetch.enable", { patterns: this._browser._fetchPatterns }]
+		];
+		if (waiting) commands.push(["Runtime.runIfWaitingForDebugger", void 0]);
+		const timeout = this._browser.commandTimeout;
+		let posted = [];
+		try {
+			posted = commands.map(([method, params]) => this.cdp.post(method, params, this._sessionId));
+			const replies = posted.map(async ({ reply }, i) => {
+				const [method, params] = commands[i];
+				try {
+					await reply;
+				} catch (err) {
+					if (err instanceof CDPError) throw commandFailed(method, params, err);
+					throw err;
+				}
+			});
+			await withTimeout(Promise.all(replies), timeout, () => new BrowserTimeoutError(`the page was not ready within ${timeout}ms`));
+		} catch (err) {
+			this._setupError = err;
+		} finally {
+			for (const { id } of posted) this.cdp.forget(id);
+			this._ready.set();
+		}
+	}
+	async close() {
+		if (this._closed) return;
+		const timeout = this._browser.commandTimeout;
+		await withTimeout(this.cdp.send("Target.closeTarget", { targetId: this._targetId }), timeout, () => new BrowserTimeoutError(`the page did not close within ${timeout}ms`));
+		this._browser._drop(this);
+	}
+	async bringToFront() {
+		await this.send("Page.bringToFront");
+	}
+	async waitForLoadState(state = "load", options = {}) {
+		const milestone = LIFECYCLE_EVENT[state];
+		const deadline = new Deadline(options.timeout ?? 3e4, `the page did not reach '${state}'`);
+		while (!this._milestones.has(milestone)) {
+			this._requireOpen();
+			deadline.check();
+			await sleep(100);
+		}
+	}
+	async goto(url, options = {}) {
+		const waitUntil = options.waitUntil ?? "load";
+		if (this._waiter !== void 0) throw new Error("navigation already in progress");
+		const waiter = new NavWaiter(LIFECYCLE_EVENT[waitUntil]);
+		this._waiter = waiter;
+		this._status = void 0;
+		const deadline = new Deadline(options.timeout ?? 3e4, `navigation to ${url} did not reach '${waitUntil}'`);
+		try {
+			const result = await deadline.race(this.send("Page.navigate", { url }));
+			if (result.errorText) throw new CDPError(`navigation to ${url} failed: ${result.errorText}`);
+			const loaderId = result.loaderId;
+			if (waitUntil === "commit" || typeof loaderId !== "string") return;
+			if (!waiter.follow(loaderId)) await deadline.race(waiter.done.wait());
+			if (waiter.error !== void 0) throw new CDPError(waiter.error);
+		} finally {
+			if (this._waiter === waiter) this._waiter = void 0;
+		}
+	}
+	async reload(options = {}) {
+		const waitUntil = options.waitUntil ?? "load";
+		if (this._waiter !== void 0) throw new Error("navigation already in progress");
+		const waiter = new NavWaiter(LIFECYCLE_EVENT[waitUntil]);
+		this._waiter = waiter;
+		this._status = void 0;
+		const deadline = new Deadline(options.timeout ?? 3e4, `reload did not reach '${waitUntil}'`);
+		try {
+			await deadline.race(this.send("Page.reload"));
+			if (!waiter.followNewest()) await deadline.race(waiter.done.wait());
+			if (waiter.error !== void 0) throw new CDPError(waiter.error);
+		} finally {
+			if (this._waiter === waiter) this._waiter = void 0;
+		}
+	}
+	goBack(options = {}) {
+		return this.#historyStep(-1, options.timeout ?? 3e4);
+	}
+	goForward(options = {}) {
+		return this.#historyStep(1, options.timeout ?? 3e4);
+	}
+	async #historyStep(delta, timeout) {
+		const history = await this.send("Page.getNavigationHistory");
+		const entries = history.entries;
+		const index = history.currentIndex + delta;
+		const entry = entries[index];
+		if (index < 0 || entry === void 0) return null;
+		await this.send("Page.navigateToHistoryEntry", { entryId: entry.id });
+		const deadline = new Deadline(timeout, "history did not move");
+		while (true) {
+			if ((await deadline.race(this.send("Page.getNavigationHistory"))).currentIndex === index) break;
+			deadline.check();
+			await sleep(100);
+		}
+		return this.url();
+	}
+	get responses() {
+		return [...this._responses];
+	}
+	/** Record responses whose URL contains a fragment. Call before navigating. */
+	async captureResponses(...fragments) {
+		if (fragments.length === 0) throw new TypeError("captureResponses needs at least one URL fragment");
+		if (this._captures.length === 0) await this.send("Network.enable");
+		this._captures.push(...fragments);
+	}
+	async stopCapturing() {
+		if (this._captures.length === 0) return;
+		this._captures = [];
+		this._responses = [];
+		this._inFlight.clear();
+		await this.send("Network.disable");
+	}
+	async waitForResponse(fragment, options = {}) {
+		if (this._captures.length === 0) throw new Error("call captureResponses() before the navigation");
+		const deadline = new Deadline(options.timeout ?? 3e4, `no response matching '${fragment}'`);
+		while (true) {
+			const found = this._responses.find((response) => response.url.includes(fragment));
+			if (found !== void 0) return found;
+			this._requireOpen();
+			deadline.check();
+			await sleep(100);
+		}
+	}
+	/** @internal */
+	_onResponse(event) {
+		const response = isRecord(event.response) ? event.response : {};
+		const url = typeof response.url === "string" ? response.url : "";
+		if (this._captures.some((fragment) => url.includes(fragment))) this._inFlight.set(String(event.requestId), response);
+	}
+	/** @internal */
+	_onBodyReady(event) {
+		const requestId = String(event.requestId ?? "");
+		const response = this._inFlight.get(requestId);
+		if (response === void 0) return;
+		this._inFlight.delete(requestId);
+		this._spawn(this.#collect(requestId, response, this._responses));
+	}
+	async #collect(requestId, response, into) {
+		let body = /* @__PURE__ */ new Uint8Array(0);
+		try {
+			const result = await this.send("Network.getResponseBody", { requestId });
+			const raw = typeof result.body === "string" ? result.body : "";
+			body = result.base64Encoded ? fromBase64(raw) : new TextEncoder().encode(raw);
+		} catch (err) {
+			this._browser.logger.debug(`no body for ${String(response.url)}: ${String(err)}`);
+		}
+		into.push(new CapturedResponse(typeof response.url === "string" ? response.url : "", typeof response.status === "number" ? response.status : 0, isRecord(response.headers) ? response.headers : {}, body));
+	}
+	localStorage() {
+		return this.#storage(true);
+	}
+	setLocalStorage(values) {
+		return this.#setStorage(values, true);
+	}
+	sessionStorage() {
+		return this.#storage(false);
+	}
+	setSessionStorage(values) {
+		return this.#setStorage(values, false);
+	}
+	async clearCookies() {
+		await this.send("Network.clearBrowserCookies");
+	}
+	async #storage(local) {
+		const items = await this.send("DOMStorage.getDOMStorageItems", { storageId: await this.#storageId(local) });
+		return Object.fromEntries(items.entries ?? []);
+	}
+	async #setStorage(values, local) {
+		const storageId = await this.#storageId(local);
+		for (const [key, value] of Object.entries(values)) await this.send("DOMStorage.setDOMStorageItem", {
+			storageId,
+			key,
+			value
+		});
+	}
+	async #storageId(local) {
+		if (!this._storageReady) {
+			await this.send("DOMStorage.enable");
+			this._storageReady = true;
+		}
+		const frame = (await this.send("Page.getFrameTree")).frameTree.frame;
+		const storageId = { isLocalStorage: local };
+		if (frame.storageKey) storageId.storageKey = frame.storageKey;
+		else storageId.securityOrigin = frame.securityOrigin;
+		return storageId;
+	}
+	/**
+	* Run script in the page. A function (or a string that looks like one) is called
+	* with `args` as JSON; anything else is an expression. It runs in an isolated world:
+	* the page's DOM, but not its globals, so the page's own script cannot see the call
+	* or hook it. Page variables (`window.__data`) need `isolated: false`, the main
+	* world, where a site that hooks the natives can notice.
+	*/
+	async evaluate(expression, options = {}) {
+		const isolated = options.isolated ?? true;
+		const awaitPromise = options.awaitPromise ?? true;
+		let expr = typeof expression === "function" ? expression.toString() : expression;
+		if (options.args !== void 0 && options.args.length > 0) expr = `(${expr})(...${JSON.stringify(options.args)})`;
+		else if (FUNCTION.test(expr)) expr = `(${expr})()`;
+		let remote = await this.#evaluate(expr, isolated, awaitPromise);
+		if (remote.type === "function" && expr.includes("=>")) remote = await this.#evaluate(`(${expr})()`, isolated, awaitPromise);
+		return remote.value;
+	}
+	async #evaluate(expression, isolated, awaitPromise) {
+		const params = {
+			expression,
+			returnByValue: true,
+			awaitPromise
+		};
+		if (isolated) params.contextId = await this.#world();
+		let result;
+		try {
+			result = await this.send("Runtime.evaluate", params);
+		} catch (err) {
+			if (!isolated || !(err instanceof CDPError) || !err.message.includes("Cannot find context")) throw err;
+			this._worldId = void 0;
+			params.contextId = await this.#world();
+			result = await this.send("Runtime.evaluate", params);
+		}
+		const details = result.exceptionDetails;
+		if (details) throw new CDPError(`evaluate failed: ${(details.exception ?? {}).description ?? details.text}`);
+		return result.result;
+	}
+	async #world() {
+		if (this._worldId === void 0) {
+			const created = await this.send("Page.createIsolatedWorld", {
+				frameId: this._frameId,
+				worldName: WORLD_NAME
+			});
+			this._worldId = created.executionContextId;
+		}
+		return this._worldId;
+	}
+	/** Poll until the expression is truthy. Returns the value. */
+	async waitForFunction(expression, options = {}) {
+		const { timeout = 3e4, ...rest } = options;
+		const deadline = new Deadline(timeout, `${typeof expression === "function" ? "the function" : `'${expression}'`} was not truthy`);
+		while (true) {
+			const value = await deadline.race(this.evaluate(expression, rest));
+			if (value) return value;
+			deadline.check();
+			await sleep(100);
+		}
+	}
+	innerText(selector) {
+		return this.evaluate("s => document.querySelector(s)?.innerText ?? null", { args: [selector] });
+	}
+	allInnerTexts(selector) {
+		return this.evaluate("s => Array.from(document.querySelectorAll(s), e => e.innerText)", { args: [selector] });
+	}
+	async getAttribute(selector, name) {
+		const nodeId = await this.#nodeId(selector);
+		if (nodeId === void 0) return null;
+		const pairs = (await this.send("DOM.getAttributes", { nodeId })).attributes ?? [];
+		for (let i = 0; i + 1 < pairs.length; i += 2) if (pairs[i] === name) return pairs[i + 1];
+		return null;
+	}
+	async count(selector) {
+		const document = await this.send("DOM.getDocument", { depth: 0 });
+		return ((await this.send("DOM.querySelectorAll", {
+			nodeId: document.root.nodeId,
+			selector
+		})).nodeIds ?? []).length;
+	}
+	async selectOption(selector, option) {
+		const { value, label } = typeof option === "string" ? { value: option } : option;
+		if (value === void 0 === (label === void 0)) throw new TypeError("selectOption takes either a value or a label");
+		const picked = await this.evaluate(SELECT, { args: [
+			selector,
+			value ?? null,
+			label ?? null
+		] });
+		if (picked === null) throw new Error(`nothing matches '${selector}'`);
+		if (picked === false) throw new Error(`'${selector}' has no option '${label ?? value}'`);
+		return picked;
+	}
+	async waitForSelector(selector, options = {}) {
+		const visible = options.visible ?? true;
+		const state = visible ? "visible" : "in the document";
+		const deadline = new Deadline(options.timeout ?? 3e4, `'${selector}' was not ${state}`);
+		while (!await deadline.race(this.#matches(selector, visible))) {
+			deadline.check();
+			await sleep(100);
+		}
+	}
+	async #matches(selector, visible) {
+		let box;
+		try {
+			const nodeId = await this.#nodeId(selector);
+			if (nodeId === void 0) return false;
+			if (!visible) return true;
+			box = await this.send("DOM.getBoxModel", { nodeId });
+		} catch (err) {
+			if (err instanceof CDPError) return false;
+			throw err;
+		}
+		const model = box.model ?? {};
+		return Boolean(model.width) && Boolean(model.height);
+	}
+	async #nodeId(selector) {
+		const document = await this.send("DOM.getDocument", { depth: 0 });
+		return (await this.send("DOM.querySelector", {
+			nodeId: document.root.nodeId,
+			selector
+		})).nodeId || void 0;
+	}
+	/** Wait until the URL contains the fragment. Returns the URL. */
+	async waitForUrl(fragment, options = {}) {
+		const deadline = new Deadline(options.timeout ?? 3e4, `the page did not reach '${fragment}'`);
+		while (true) {
+			const url = await deadline.race(this.url());
+			if (url.includes(fragment)) return url;
+			deadline.check();
+			await sleep(100);
+		}
+	}
+	/** The first match has a bounding box. */
+	isVisible(selector) {
+		return this.#matches(selector, true);
+	}
+	async outerHtml(selector) {
+		const nodeId = await this.#nodeId(selector);
+		if (nodeId === void 0) return null;
+		return (await this.send("DOM.getOuterHTML", { nodeId })).outerHTML;
+	}
+	async setCookies(cookies) {
+		await this.send("Network.setCookies", { cookies: cookies.map(cookieParam) });
+	}
+	async content() {
+		const document = await this.send("DOM.getDocument", { depth: 0 });
+		return (await this.send("DOM.getOuterHTML", { nodeId: document.root.nodeId })).outerHTML;
+	}
+	async title() {
+		return (await this.send("Target.getTargetInfo", { targetId: this._targetId })).targetInfo.title;
+	}
+	async url() {
+		return (await this.send("Target.getTargetInfo", { targetId: this._targetId })).targetInfo.url;
+	}
+	async cookies() {
+		return ((await this.send("Network.getCookies")).cookies ?? []).map(fromCdpCookie);
+	}
+	async screenshot(options = {}) {
+		const format = options.format ?? "png";
+		const fullPage = options.fullPage ?? false;
+		const params = {
+			format,
+			captureBeyondViewport: fullPage
+		};
+		if (options.quality !== void 0 && format !== "png") params.quality = options.quality;
+		if (options.selector !== void 0) params.clip = await this.#clip(options.selector);
+		else if (fullPage) {
+			const metrics = await this.send("Page.getLayoutMetrics");
+			params.clip = {
+				x: 0,
+				y: 0,
+				scale: 1,
+				...metrics.cssContentSize ?? metrics.contentSize
+			};
+		}
+		return fromBase64((await this.send("Page.captureScreenshot", params)).data);
+	}
+	async #clip(selector) {
+		const nodeId = await this.#nodeId(selector);
+		if (nodeId === void 0) throw new Error(`nothing matches '${selector}'`);
+		await this.send("DOM.scrollIntoViewIfNeeded", { nodeId });
+		const box = await this.send("DOM.getBoxModel", { nodeId });
+		const metrics = await this.send("Page.getLayoutMetrics");
+		const viewport = metrics.cssVisualViewport ?? metrics.visualViewport ?? {};
+		const quad = box.model.content;
+		return {
+			x: quad[0] + (viewport.pageX ?? 0),
+			y: quad[1] + (viewport.pageY ?? 0),
+			width: quad[2] - quad[0],
+			height: quad[5] - quad[1],
+			scale: 1
+		};
+	}
+	/** @internal */
+	_onLifecycle(event) {
+		if (event.frameId !== this._frameId) return;
+		const name = event.name ?? "";
+		const loaderId = event.loaderId;
+		if (name === "init") {
+			this._loaderId = loaderId;
+			this._milestones = /* @__PURE__ */ new Set();
+			this._worldId = void 0;
+		} else if (loaderId === this._loaderId) this._milestones.add(name);
+		else if (this._loaderId === void 0) {
+			this._loaderId = loaderId;
+			this._milestones = /* @__PURE__ */ new Set([name]);
+		}
+		this._waiter?.observe(name, loaderId);
+	}
+	/** @internal */
+	_onDialog(event) {
+		const kind = event.type ?? "";
+		const message = event.message ?? "";
+		const handler = this.onDialog ?? this._browser.onDialog;
+		let verdict;
+		try {
+			verdict = handler ? handler(kind, message) : void 0;
+		} catch (err) {
+			this._browser.logger.error(`onDialog failed, falling back to the default: ${String(err)}`);
+			verdict = void 0;
+		}
+		if (verdict === void 0 || verdict === null) verdict = kind === "beforeunload";
+		const params = { accept: verdict !== false };
+		if (typeof verdict === "string") params.promptText = verdict;
+		this._browser.logger.info(`${kind} dialog '${message}' ${params.accept ? "accepted" : "dismissed"}`);
+		this._spawn(this.#answerDialog(params));
+	}
+	async #answerDialog(params) {
+		const [min, max] = DIALOG_DELAY;
+		await sleep(min + Math.random() * (max - min), this._browser._signal);
+		if (this._browser._signal.aborted) return;
+		await this._send("Page.handleJavaScriptDialog", params);
+	}
+	/** @internal */
+	_onRequestPaused(event) {
+		const requestId = event.requestId;
+		if (requestId === void 0 || requestId === null) {
+			this._browser.logger.warn("Fetch.requestPaused without a requestId");
+			return;
+		}
+		const status = event.responseStatusCode;
+		if (status !== void 0 && status !== null) {
+			if (event.frameId === this._frameId) this._status = status;
+			this._spawn(this._send("Fetch.continueResponse", { requestId }));
+		} else if (event.responseErrorReason) this._spawn(this._send("Fetch.continueRequest", { requestId }));
+		else this._spawn(this._send("Fetch.failRequest", {
+			requestId,
+			errorReason: "BlockedByClient"
+		}));
+	}
+	/** @internal */
+	_spawn(task) {
+		this._browser._spawn(task);
+	}
+};
+//#endregion
+//#region src/browser/browser.ts
+const STATUS_PATTERN = {
+	urlPattern: "*",
+	resourceType: "Document",
+	requestStage: "Response"
+};
+const AUTO_ATTACH = {
+	autoAttach: true,
+	waitForDebuggerOnStart: true,
+	flatten: true,
+	filter: [{ type: "page" }]
+};
+const NON_WEB_SCHEMES = [
+	"chrome-extension://",
+	"devtools://",
+	"chrome://"
+];
+const START_PAGES = ["chrome://newtab", "chrome://new-tab-page"];
+function isStartPage(url) {
+	return START_PAGES.some((page) => url.startsWith(page));
+}
+const RESOURCE_TYPES = Object.fromEntries([
+	"Stylesheet",
+	"Image",
+	"Media",
+	"Font",
+	"Script",
+	"TextTrack",
+	"XHR",
+	"Fetch",
+	"Prefetch",
+	"EventSource",
+	"WebSocket",
+	"Manifest",
+	"SignedExchange",
+	"Ping",
+	"CSPViolationReport",
+	"Preflight",
+	"FedCM",
+	"Other"
+].map((name) => [name.toLowerCase(), name]));
+function normalizeBlocked(resources) {
+	if (typeof resources === "string") throw new TypeError("blockResources takes a list of resource types, not 1 string");
+	const blocked = new Set([...resources ?? []].map((name) => name.toLowerCase()));
+	if (blocked.has("document")) throw new TypeError("blocking 'document' blocks the page itself");
+	const unknown = [...blocked].filter((name) => !(name in RESOURCE_TYPES)).sort();
+	if (unknown.length > 0) {
+		const valid = Object.keys(RESOURCE_TYPES).sort();
+		throw new TypeError(`unknown resource types ${JSON.stringify(unknown)}; valid: ${JSON.stringify(valid)}`);
+	}
+	return blocked;
+}
+function normalizeUrls(patterns) {
+	if (typeof patterns === "string") throw new TypeError("blockUrls takes a list of patterns, not 1 string");
+	return [...patterns ?? []];
+}
+/** A connected cloud browser, and the page its session started with. */
+var Browser = class extends Page {
+	session;
+	data = {};
+	blockedResources;
+	blockedUrls;
+	connectTimeout;
+	commandTimeout;
+	logger;
+	/** @internal */ _pages = /* @__PURE__ */ new Map();
+	/** @internal aborts on close: background sleeps end early */
+	_signal;
+	#createWebSocket;
+	#onClose;
+	#client;
+	#abort = new AbortController();
+	#pending = /* @__PURE__ */ new Set();
+	#closing;
+	#retired = false;
+	#useCount = 0;
+	constructor(session, options = {}) {
+		super(void 0, "", "");
+		this.session = session;
+		this.blockedResources = normalizeBlocked(options.blockResources);
+		this.blockedUrls = normalizeUrls(options.blockUrls);
+		this.connectTimeout = options.connectTimeout ?? 3e4;
+		this.commandTimeout = options.commandTimeout === void 0 ? 6e4 : options.commandTimeout;
+		this.logger = makeLogger(options.logger);
+		this.#createWebSocket = options.createWebSocket;
+		this.#onClose = options.onClose;
+		this._signal = this.#abort.signal;
+	}
+	get internalUuid() {
+		return this.session.internal_uuid;
+	}
+	get cdp() {
+		if (this.#client === void 0) throw new Error("browser is not connected; call connect() first");
+		return this.#client;
+	}
+	get connected() {
+		return this.#client?.connected ?? false;
+	}
+	get shouldRecycle() {
+		return this.#retired || !this.connected;
+	}
+	/**
+	* Leases so far, the current one included. Rotate the browser from your own loop:
+	*
+	*     if (browser.useCount >= 20) browser.retire();
+	*/
+	get useCount() {
+		return this.#useCount;
+	}
+	/** @internal */
+	_lease() {
+		this.#useCount += 1;
+	}
+	get pages() {
+		return [...this._pages.values()];
+	}
+	/** @internal what a page's Fetch.enable intercepts */
+	get _fetchPatterns() {
+		const patterns = [...this.blockedResources].sort().map((name) => ({
+			urlPattern: "*",
+			resourceType: RESOURCE_TYPES[name]
+		}));
+		for (const pattern of this.blockedUrls) patterns.push({ urlPattern: pattern });
+		return [...patterns, STATUS_PATTERN];
+	}
+	/** Replace this browser with a fresh one after the lease. */
+	retire() {
+		this.#retired = true;
+	}
+	async newPage() {
+		const deadline = new Deadline(this.commandTimeout, "the new page did not open");
+		const created = await deadline.race(this.cdp.send("Target.createTarget", {
+			url: "about:blank",
+			newWindow: true
+		}));
+		return this._pageReady(created.targetId, deadline);
+	}
+	/**
+	* Run `action`, the click that opens a window, and return the page it opened:
+	*
+	*     const popup = await browser.waitForPage(browser.click("a[target=_blank]"));
+	*
+	* A site can open the window after an async step, so `pages` right after the
+	* click may not have it yet.
+	*/
+	async waitForPage(action, options = {}) {
+		const before = new Set(this._pages.keys());
+		const deadline = new Deadline(options.timeout ?? 3e4, "no page opened");
+		await deadline.race(typeof action === "function" ? action() : action);
+		while (true) {
+			const opened = [...this._pages.entries()].filter(([sessionId]) => !before.has(sessionId)).map(([, page]) => page);
+			const last = opened[opened.length - 1];
+			if (last !== void 0) return last;
+			this._requireOpen();
+			deadline.check();
+			await sleep(100);
+		}
+	}
+	async connect() {
+		if (this.#client !== void 0) throw new Error("browser is already connected");
+		const handler = this.onDialog;
+		this._reset("", "");
+		this.onDialog = handler;
+		this._pages = /* @__PURE__ */ new Map();
+		this.#abort = new AbortController();
+		this._signal = this.#abort.signal;
+		this.#closing = void 0;
+		const deadline = new Deadline(this.connectTimeout, "could not connect");
+		try {
+			const client = new CDPClient(this.session.ws_url, {
+				createWebSocket: this.#createWebSocket,
+				onClose: () => this._onDisconnect(),
+				logger: this.logger
+			});
+			this.#client = client;
+			await deadline.race(client.start());
+			client.on("Target.attachedToTarget", (event) => this._onAttached(event));
+			client.on("Target.detachedFromTarget", (event) => this._onDetached(event));
+			client.on("Inspector.targetCrashed", this.#toPage((page) => this._drop(page)));
+			client.on("Page.lifecycleEvent", this.#toPage((page, event) => page._onLifecycle(event)));
+			client.on("Fetch.requestPaused", this.#toPage((page, event) => page._onRequestPaused(event)));
+			client.on("Network.responseReceived", this.#toPage((page, event) => page._onResponse(event)));
+			client.on("Network.loadingFinished", this.#toPage((page, event) => page._onBodyReady(event)));
+			client.on("Page.javascriptDialogOpening", this.#toPage((page, event) => page._onDialog(event)));
+			await deadline.race(client.send("Target.setAutoAttach", AUTO_ATTACH));
+			await deadline.race(client.send("Target.getTargets"));
+			if (!this._sessionId) {
+				const created = await deadline.race(client.send("Target.createTarget", { url: "about:blank" }));
+				await this._pageReady(created.targetId, deadline);
+			}
+			await deadline.race(this._waitReady());
+		} catch (err) {
+			await this.close();
+			throw err;
+		}
+	}
+	close() {
+		this.#closing ??= this.#close();
+		return this.#closing;
+	}
+	async #close() {
+		this.#abort.abort();
+		const pending = [...this.#pending];
+		this.#pending.clear();
+		const client = this.#client;
+		this.#client = void 0;
+		await withTimeout(Promise.allSettled(pending), 5e3, () => new BrowserTimeoutError("close timed out")).catch((err) => this.logger.debug(`close: ${String(err)}`));
+		if (client !== void 0) await client.stop();
+		this._closed = true;
+		await this.#onClose?.();
+	}
+	[Symbol.asyncDispose]() {
+		return this.close();
+	}
+	/** @internal a lease ends: other pages closed, captures dropped, dialogs reset; `data` stays */
+	async _endLease() {
+		for (const page of this.pages) if (page !== this) await page.close();
+		await this.stopCapturing();
+		this.onDialog = null;
+		const timeout = this.commandTimeout;
+		await withTimeout(this.cdp.send("Browser.getVersion"), timeout, () => new BrowserTimeoutError(`the browser did not answer within ${timeout}ms`));
+	}
+	/** @internal */
+	async _pageReady(targetId, deadline) {
+		let page = this.#pageFor(targetId);
+		while (page === void 0) {
+			this._requireOpen();
+			deadline.check();
+			await sleep(100);
+			page = this.#pageFor(targetId);
+		}
+		await deadline.race(page._waitReady());
+		return page;
+	}
+	#pageFor(targetId) {
+		for (const page of this._pages.values()) if (page._targetId === targetId) return page;
+	}
+	/** @internal */
+	_onAttached(event) {
+		const info = event.targetInfo ?? {};
+		const sessionId = event.sessionId;
+		const waiting = Boolean(event.waitingForDebugger);
+		const url = info.url ?? "";
+		const adoptable = isStartPage(url) && !this._sessionId;
+		if (info.type !== "page" || NON_WEB_SCHEMES.some((scheme) => url.startsWith(scheme)) && !adoptable) {
+			this._spawn(this.#letGo(sessionId, waiting));
+			return;
+		}
+		let page;
+		if (this._sessionId) page = new Page(this, info.targetId, sessionId);
+		else {
+			page = this;
+			this._targetId = info.targetId;
+			this._sessionId = sessionId;
+		}
+		page._frameId = page._targetId;
+		page._ready = new Flag();
+		this._pages.set(sessionId, page);
+		this._spawn(page._setup(waiting));
+	}
+	async #letGo(sessionId, waiting) {
+		const timeout = this.commandTimeout;
+		const detach = async () => {
+			if (waiting) await this.cdp.send("Runtime.runIfWaitingForDebugger", void 0, sessionId);
+			await this.cdp.send("Target.detachFromTarget", { sessionId });
+		};
+		await withTimeout(detach(), timeout, () => new BrowserTimeoutError(`the target did not let go within ${timeout}ms`));
+	}
+	/** @internal */
+	_onDetached(event) {
+		const page = this._pages.get(String(event.sessionId ?? ""));
+		if (page !== void 0) this._drop(page);
+	}
+	/** @internal */
+	_drop(page) {
+		this._pages.delete(page._sessionId);
+		page._closed = true;
+		page._waiter?.fail("page closed");
+		if (page === this) {
+			this.logger.warn(`page target gone for ${this.internalUuid}`);
+			this.retire();
+		}
+	}
+	#toPage(handler) {
+		return (event, sessionId) => {
+			const page = this._pages.get(sessionId ?? "");
+			if (page !== void 0) handler(page, event);
+		};
+	}
+	/** @internal */
+	_onDisconnect() {
+		for (const page of this._pages.values()) {
+			page._closed = true;
+			page._waiter?.fail("CDP connection closed");
+		}
+	}
+	/** @internal track a background task; its failure is logged at debug level */
+	_spawn(task) {
+		const tracked = task.then(() => void 0, (err) => this.logger.debug(`background task failed: ${String(err)}`));
+		this.#pending.add(tracked);
+		tracked.then(() => this.#pending.delete(tracked));
+	}
+};
+//#endregion
+//#region src/proxy.ts
+function proxyList(proxies, owner) {
+	if (typeof proxies === "string") throw new TypeError(`${owner} takes an iterable of proxies, not a single URL`);
+	const list = [...proxies];
+	if (list.length === 0) throw new RangeError(`${owner} needs at least one proxy`);
+	for (const proxy of list) parseProxyLike(proxy, owner);
+	return list;
+}
+/** Round-robin over a list. */
+var ProxyCycle = class {
+	proxies;
+	#index = 0;
+	constructor(proxies) {
+		this.proxies = proxyList(proxies, "ProxyCycle");
+	}
+	pick() {
+		const proxy = this.proxies[this.#index % this.proxies.length];
+		this.#index += 1;
+		return proxy;
+	}
+};
+var ProxyRandom = class {
+	proxies;
+	constructor(proxies) {
+		this.proxies = proxyList(proxies, "ProxyRandom");
+	}
+	pick() {
+		return this.proxies[Math.floor(Math.random() * this.proxies.length)];
+	}
+};
+const PLACEHOLDER = /\{\{|\}\}|\{([^{}]*)\}/g;
+function format(template, values) {
+	return template.replace(PLACEHOLDER, (match, name) => {
+		if (match === "{{") return "{";
+		if (match === "}}") return "}";
+		if (name === void 0 || !Object.hasOwn(values, name)) throw new TypeError(`unknown placeholder in proxy template: '${name ?? ""}'`);
+		return String(values[name]);
+	});
+}
+function hex(bytes) {
+	const buffer = new Uint8Array(bytes);
+	crypto.getRandomValues(buffer);
+	return Array.from(buffer, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* A proxy URL from a template: `{session}` is a fresh hex id, `{n}` a counter.
+* Covers the sticky-session syntax providers put in the username:
+*
+*     new ProxyTemplate("http://user-cc-us-sessid-{session}:pw@gate.example.com:7000")
+*
+* Literal braces are `{{` and `}}`.
+*/
+var ProxyTemplate = class {
+	template;
+	#count = 0;
+	constructor(template) {
+		format(template, {
+			session: "0".repeat(12),
+			n: 0
+		});
+		this.template = template;
+	}
+	pick() {
+		const n = this.#count;
+		this.#count += 1;
+		return format(this.template, {
+			session: hex(6),
+			n
+		});
+	}
+};
+function isProxySource(value) {
+	return isRecord(value) && typeof value.pick === "function";
+}
+async function resolveProxy(proxy) {
+	return typeof proxy === "function" ? proxy() : isProxySource(proxy) ? proxy.pick() : proxy;
+}
+//#endregion
+//#region src/resources/profiles.ts
+const SCRAPE_TIMEOUT = 15e4;
+function sessionUuid(session) {
+	return ref(typeof session === "string" ? session : session.internal_uuid);
+}
+function startOneTimeSpec(options, proxy) {
+	return {
+		method: "POST",
+		path: "/profiles/one_time",
+		json: parseOneTimeStartRequest({
+			...options,
+			proxy
+		})
+	};
+}
+function startSpec(uuid, options, proxy) {
+	const request = parseProfileStartRequest({
+		...options,
+		proxy
+	});
+	return {
+		method: "POST",
+		path: `/profiles/${ref(uuid)}/start`,
+		json: request
+	};
+}
+function stopSpec(session) {
+	return {
+		method: "POST",
+		path: `/profiles/${sessionUuid(session)}/stop`,
+		parse: (data) => data ? data : null
+	};
+}
+function stopAllSpec() {
+	return {
+		method: "POST",
+		path: "/profiles/stop"
+	};
+}
+function listActiveSpec() {
+	return {
+		method: "GET",
+		path: "/profiles/active",
+		parse: (data) => data ?? []
+	};
+}
+function createSpec(options, proxy) {
+	return {
+		method: "POST",
+		path: "/profiles",
+		json: parseProfileCreateRequest({
+			...options,
+			proxy
+		})
+	};
+}
+function getSpec$1(uuid) {
+	return {
+		method: "GET",
+		path: `/profiles/${ref(uuid)}`
+	};
+}
+function updateSpec$1(uuid, fields) {
+	const body = parseProfileUpdateRequest(fields);
+	for (const [key, value] of Object.entries(fields)) if (value === null) body[key] = null;
+	return {
+		method: "PATCH",
+		path: `/profiles/${ref(uuid)}`,
+		json: body
+	};
+}
+function deleteSpec$1(uuid) {
+	return {
+		method: "DELETE",
+		path: `/profiles/${ref(uuid)}`
+	};
+}
+function deleteManySpec(uuids) {
+	return {
+		method: "DELETE",
+		path: "/profiles",
+		json: { uuids },
+		acceptError: (status, body) => status === 400 && isRecord(body) && isRecord(body.data) && "deleted_uuids" in body.data
+	};
+}
+function listPageSpec(options) {
+	const { page, page_len, ordering } = parseListPageRequest(options);
+	return {
+		method: "GET",
+		path: "/profiles",
+		params: {
+			page,
+			page_len,
+			ordering
+		},
+		parse: (data) => data ?? []
+	};
+}
+function exportCookiesSpec(uuid, exportFormat) {
+	return {
+		method: "GET",
+		path: `/profiles/${ref(uuid)}/cookies`,
+		params: { export_format: exportFormat },
+		parse: (data) => {
+			const cookies = isRecord(data) ? data.cookies : void 0;
+			if (typeof cookies === "string") return cookies;
+			return cookies ?? [];
+		}
+	};
+}
+function importCookiesSpec(uuid, cookies) {
+	const text = typeof cookies === "string" ? cookies : JSON.stringify(dropNulls(cookies));
+	return {
+		method: "POST",
+		path: `/profiles/${ref(uuid)}/cookies`,
+		json: { cookies: text },
+		parse: () => void 0
+	};
+}
+function scrapeSpec(session, request) {
+	return {
+		method: "POST",
+		path: `/profiles/${sessionUuid(session)}/scrape`,
+		json: parseScrapeRequest(request),
+		timeout: SCRAPE_TIMEOUT
+	};
+}
+const STOP_TIMEOUT = 8e3;
+const STOP_DEADLINE = 1e4;
+/** One fast attempt to stop a session; a failure is logged, never thrown. */
+async function stopSession(client, internalUuid) {
+	const fast = client.withOptions({
+		timeout: STOP_TIMEOUT,
+		maxRetries: 0
+	});
+	const timedOut = Symbol("timed out");
+	try {
+		await withTimeout(fast.profiles.stop(internalUuid), STOP_DEADLINE, () => Object.assign(/* @__PURE__ */ new Error("stop timed out"), { [timedOut]: true }));
+	} catch (err) {
+		if (err instanceof Error && timedOut in err) client.logger.warn(`stopping session ${internalUuid} timed out; it may keep billing`);
+		else client.logger.warn(`failed to stop session ${internalUuid}: ${String(err)}`);
+	}
+}
+var Profiles = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	/** Start a session on a fresh browser that is gone once stopped. */
+	async startOneTime(options = {}) {
+		const proxy = await resolveProxy(options.proxy);
+		return this.client.call(startOneTimeSpec(options, proxy));
+	}
+	/** Start a session on a saved profile. */
+	async start(uuid, options = {}) {
+		const proxy = await resolveProxy(options.proxy);
+		return this.client.call(startSpec(uuid, options, proxy));
+	}
+	async stop(session) {
+		return this.client.call(stopSpec(session));
+	}
+	async stopAll() {
+		return this.client.call(stopAllSpec());
+	}
+	async listActive() {
+		return this.client.call(listActiveSpec());
+	}
+	async create(options) {
+		const proxy = await resolveProxy(options.proxy);
+		return this.client.call(createSpec(options, proxy));
+	}
+	async get(uuid) {
+		return this.client.call(getSpec$1(uuid));
+	}
+	async update(uuid, fields) {
+		const { proxy, ...rest } = fields;
+		return this.client.call(updateSpec$1(uuid, {
+			...rest,
+			proxy: await resolveProxy(proxy)
+		}));
+	}
+	async delete(uuid) {
+		return this.client.call(deleteSpec$1(uuid));
+	}
+	async deleteMany(uuids) {
+		return this.client.call(deleteManySpec(uuids));
+	}
+	async listPage(options = {}) {
+		return this.client.call(listPageSpec(options));
+	}
+	/** Every profile, page by page. */
+	async *iterAll(options = {}) {
+		const pageLen = Math.max(1, Math.min(options.page_len ?? 100, 100));
+		const ordering = options.ordering ?? "created";
+		for (let page = 0;; page++) {
+			const batch = await this.listPage({
+				page,
+				page_len: pageLen,
+				ordering
+			});
+			yield* batch;
+			if (batch.length < pageLen) return;
+		}
+	}
+	async exportCookies(uuid, options = {}) {
+		return this.client.call(exportCookiesSpec(uuid, options.export_format ?? "json"));
+	}
+	async importCookies(uuid, cookies) {
+		return this.client.call(importCookiesSpec(uuid, cookies));
+	}
+	async scrape(session, url, options = {}) {
+		return this.client.call(scrapeSpec(session, {
+			url,
+			...options
+		}));
+	}
+};
+//#endregion
+//#region src/browser/pool.ts
+/** Throw from a `map` handler to end the run after this item. */
+var StopRun = class extends Error {
+	constructor(message = "run stopped") {
+		super(message);
+		this.name = "StopRun";
+	}
+};
+function planIsFull(err) {
+	return err instanceof RateLimitError && err.code === "parallel_browsers_limit_reached";
+}
+var Semaphore = class {
+	#free;
+	#waiters = [];
+	constructor(slots) {
+		this.#free = slots;
+	}
+	acquire() {
+		if (this.#free > 0) {
+			this.#free -= 1;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => this.#waiters.push(resolve));
+	}
+	release() {
+		const next = this.#waiters.shift();
+		if (next !== void 0) next();
+		else this.#free += 1;
+	}
+};
+var BrowserPool = class {
+	sessionOptions;
+	blockedResources;
+	blockedUrls;
+	#client;
+	#concurrency;
+	#createWebSocket;
+	#idle = [];
+	#owned = 0;
+	#planFull = false;
+	#planFullError;
+	#waiters = [];
+	#capacity = 0;
+	#slots;
+	constructor(client, options = {}) {
+		const { concurrency = "auto", blockResources, blockUrls, createWebSocket, ...sessionOptions } = options;
+		if (concurrency !== "auto" && !Number.isInteger(concurrency)) throw new TypeError("concurrency must be a whole number or \"auto\"");
+		this.#client = client;
+		this.#concurrency = concurrency;
+		this.blockedResources = normalizeBlocked(blockResources);
+		this.blockedUrls = normalizeUrls(blockUrls);
+		this.#createWebSocket = createWebSocket;
+		const { proxy } = sessionOptions;
+		parseOneTimeStartRequest({
+			...sessionOptions,
+			proxy: typeof proxy === "function" || isProxySource(proxy) ? void 0 : proxy
+		});
+		this.sessionOptions = sessionOptions;
+	}
+	/** Max live browsers. */
+	get capacity() {
+		this.#requireOpen();
+		return this.#capacity;
+	}
+	#requireOpen() {
+		if (this.#slots === void 0) throw new Error("the pool is not open: use `await client.browsers()` or `open()`");
+		return this.#slots;
+	}
+	async open() {
+		const total = this.#concurrency === "auto" ? await this.#client.account.maxBrowsers() : this.#concurrency;
+		this.#capacity = Math.max(1, total);
+		this.#slots = new Semaphore(this.#capacity);
+		this.#planFull = false;
+		this.#planFullError = void 0;
+		this.#owned = 0;
+		return this;
+	}
+	/** Stop every idle browser. A browser still on lease is stopped when its lease ends. */
+	async close() {
+		this.#slots = void 0;
+		const idle = this.#idle;
+		this.#idle = [];
+		this.#owned -= idle.length;
+		await Promise.all(idle.map((browser) => this.#teardown(browser)));
+	}
+	[Symbol.asyncDispose]() {
+		return this.close();
+	}
+	/** Run `fn` on a live browser, then hand the browser back. Waits while all are busy. */
+	async lease(fn) {
+		const slots = this.#requireOpen();
+		await slots.acquire();
+		try {
+			if (this.#slots !== slots) throw new Error("the pool was closed while waiting for a slot");
+			const browser = await this.#acquire();
+			browser._lease();
+			try {
+				return await fn(browser);
+			} finally {
+				await this.#release(browser);
+			}
+		} finally {
+			slots.release();
+		}
+	}
+	#wait() {
+		return new Promise((resolve) => this.#waiters.push(resolve));
+	}
+	#notifyAll() {
+		const waiters = this.#waiters;
+		this.#waiters = [];
+		for (const wake of waiters) wake();
+	}
+	async #acquire() {
+		while (true) {
+			const dead = this.#idle.filter((browser) => browser.shouldRecycle);
+			if (dead.length > 0) {
+				this.#idle = this.#idle.filter((browser) => !browser.shouldRecycle);
+				this.#owned -= dead.length;
+				this.#planFull = false;
+				this.#notifyAll();
+				await Promise.all(dead.map((browser) => this.#teardown(browser)));
+				continue;
+			}
+			const idle = this.#idle.pop();
+			if (idle !== void 0) return idle;
+			if (this.#planFull) {
+				if (this.#owned === 0) throw this.#planFullError ?? new RateLimitError("parallel browser limit reached", { statusCode: 429 });
+				await this.#wait();
+				continue;
+			}
+			this.#owned += 1;
+			let browser;
+			try {
+				browser = await this.#startBrowser();
+			} catch (err) {
+				const full = planIsFull(err);
+				this.#owned -= 1;
+				if (full) {
+					this.#planFull = true;
+					this.#planFullError = err;
+				}
+				const nothingLeft = this.#owned === 0;
+				this.#notifyAll();
+				if (!full || nothingLeft) throw err;
+				this.#client.logger.info("plan is full, waiting for a browser of ours");
+				continue;
+			}
+			this.#planFull = false;
+			return browser;
+		}
+	}
+	async #release(browser) {
+		if (!browser.shouldRecycle) try {
+			await withTimeout(browser._endLease(), 5e3, () => new BrowserTimeoutError("lease cleanup timed out"));
+		} catch (err) {
+			this.#client.logger.warn(`could not clean up ${browser.internalUuid}: ${String(err)}`);
+			browser.retire();
+		}
+		const recycle = browser.shouldRecycle || this.#slots === void 0;
+		if (recycle) await this.#teardown(browser);
+		if (recycle) {
+			this.#owned -= 1;
+			this.#planFull = false;
+		} else this.#idle.push(browser);
+		this.#notifyAll();
+	}
+	/** Run every item through `handler` on a leased browser, `capacity` at a time. */
+	async map(handler, items) {
+		const work = items[Symbol.iterator]();
+		const outcomes = [];
+		let index = 0;
+		let stopped = false;
+		const worker = async () => {
+			while (!stopped) {
+				const next = work.next();
+				if (next.done) return;
+				const item = next.value;
+				const at = index;
+				index += 1;
+				try {
+					const value = await this.lease((browser) => handler(browser, item));
+					outcomes.push({
+						ok: true,
+						item,
+						index: at,
+						value
+					});
+				} catch (error) {
+					outcomes.push({
+						ok: false,
+						item,
+						index: at,
+						error
+					});
+					if (error instanceof StopRun) {
+						stopped = true;
+						return;
+					}
+				}
+			}
+		};
+		await Promise.all(Array.from({ length: this.capacity }, worker));
+		return outcomes.sort((a, b) => a.index - b.index);
+	}
+	async #startBrowser() {
+		const session = await this.#client.profiles.startOneTime(this.sessionOptions);
+		let browser;
+		try {
+			browser = new Browser(session, {
+				blockResources: this.blockedResources,
+				blockUrls: this.blockedUrls,
+				createWebSocket: this.#createWebSocket,
+				logger: this.#client.logger
+			});
+			await browser.connect();
+		} catch (err) {
+			await stopSession(this.#client, session.internal_uuid);
+			throw err;
+		}
+		this.#client.logger.info(`pool browser ${browser.internalUuid} started`);
+		return browser;
+	}
+	async #teardown(browser) {
+		await browser.close();
+		await stopSession(this.#client, browser.internalUuid);
+	}
+};
+function sessionLimitsSpec() {
+	return {
+		method: "GET",
+		path: "/users/session-limits"
+	};
+}
+function browserLimitsSpec() {
+	return {
+		method: "GET",
+		path: "/users/browser-limits"
+	};
+}
+function envMaxBrowsers() {
+	const value = process.env.SURFSKY_MAX_BROWSERS ?? "";
+	return /^\d+$/.test(value) ? Math.max(1, Number(value)) : void 0;
+}
+var Account = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async sessionLimits() {
+		return this.client.call(sessionLimitsSpec());
+	}
+	async browserLimits() {
+		return this.client.call(browserLimitsSpec());
+	}
+	/** The plan's parallel-browser cap; `SURFSKY_MAX_BROWSERS` overrides it. */
+	async maxBrowsers() {
+		return envMaxBrowsers() ?? ((await this.#limits()).parallel_browsers || 10);
+	}
+	async #limits() {
+		try {
+			return await this.browserLimits();
+		} catch (err) {
+			if (err instanceof NotFoundError) return {};
+			throw err;
+		}
+	}
+};
+//#endregion
+//#region src/resources/extensions.ts
+async function readExtension(file) {
+	if (typeof file === "string") {
+		const [{ readFile }, { basename }] = await Promise.all([import("node:fs/promises"), import("node:path")]);
+		const bytes = new Uint8Array(await readFile(file));
+		return {
+			name: basename(file),
+			blob: new Blob([bytes], { type: "application/zip" })
+		};
+	}
+	if (file instanceof Blob) return {
+		name: "name" in file && typeof file.name === "string" ? file.name : "extension.zip",
+		blob: file
+	};
+	return {
+		name: "extension.zip",
+		blob: new Blob([new Uint8Array(file)], { type: "application/zip" })
+	};
+}
+function uploadSpec(name, filename, blob) {
+	const form = new FormData();
+	form.append("file", blob, filename);
+	form.append("name", name);
+	return {
+		method: "POST",
+		path: "/extensions",
+		body: form
+	};
+}
+function listAllSpec() {
+	return {
+		method: "GET",
+		path: "/extensions",
+		parse: (data) => isRecord(data) ? data.extensions ?? [] : []
+	};
+}
+function getSpec(uuid) {
+	return {
+		method: "GET",
+		path: `/extensions/${ref(uuid)}`
+	};
+}
+function updateSpec(uuid, name) {
+	return {
+		method: "PATCH",
+		path: `/extensions/${ref(uuid)}`,
+		json: { name }
+	};
+}
+function deleteSpec(uuid) {
+	return {
+		method: "DELETE",
+		path: `/extensions/${ref(uuid)}`,
+		parse: () => void 0
+	};
+}
+var Extensions = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	/** Upload a zip (max 100 MB) given as a path, bytes or a Blob. */
+	async upload(file, name) {
+		const { name: filename, blob } = await readExtension(file);
+		return this.client.call(uploadSpec(name, filename, blob));
+	}
+	async listAll() {
+		return this.client.call(listAllSpec());
+	}
+	async get(uuid) {
+		return this.client.call(getSpec(uuid));
+	}
+	async update(uuid, options) {
+		return this.client.call(updateSpec(uuid, options.name));
+	}
+	async delete(uuid) {
+		return this.client.call(deleteSpec(uuid));
+	}
+};
+//#endregion
+//#region src/resources/fingerprints.ts
+const list$1 = (data) => data ?? [];
+function renderersSpec(os, osArch) {
+	return {
+		method: "GET",
+		path: "/fingerprint/renderers",
+		params: {
+			os,
+			os_arch: osArch
+		},
+		parse: list$1
+	};
+}
+function screensSpec(os, osArch) {
+	return {
+		method: "GET",
+		path: "/fingerprint/screens",
+		params: {
+			os,
+			os_arch: osArch
+		},
+		parse: list$1
+	};
+}
+function deviceModelsSpec(options) {
+	return {
+		method: "GET",
+		path: "/fingerprint/device_models",
+		params: {
+			os: options.os,
+			os_arch: options.os_arch,
+			os_version: options.os_version,
+			device_type: options.device_type
+		},
+		parse: list$1
+	};
+}
+var Fingerprints = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async renderers(os, osArch) {
+		return this.client.call(renderersSpec(os, osArch));
+	}
+	async screens(os, osArch) {
+		return this.client.call(screensSpec(os, osArch));
+	}
+	async deviceModels(options = {}) {
+		return this.client.call(deviceModelsSpec(options));
+	}
+};
+//#endregion
+//#region src/resources/proxies.ts
+const list = (data) => data ?? [];
+function countriesSpec() {
+	return {
+		method: "GET",
+		path: "/proxies/countries",
+		parse: list
+	};
+}
+function regionsSpec(country) {
+	return {
+		method: "GET",
+		path: `/proxies/regions/${ref(country)}`,
+		parse: list
+	};
+}
+function citiesSpec(country, region) {
+	return {
+		method: "GET",
+		path: `/proxies/cities/${ref(country)}/${ref(region)}`,
+		parse: list
+	};
+}
+function quotaSpec() {
+	return {
+		method: "GET",
+		path: "/proxies/quota"
+	};
+}
+function premiumStatsSpec() {
+	return {
+		method: "GET",
+		path: "/proxies/premium/stats"
+	};
+}
+function sharedCountriesSpec() {
+	return {
+		method: "GET",
+		path: "/proxies/shared/countries",
+		parse: list
+	};
+}
+function sharedQuotaSpec() {
+	return {
+		method: "GET",
+		path: "/proxies/shared/quota"
+	};
+}
+function sharedStatsSpec() {
+	return {
+		method: "GET",
+		path: "/proxies/shared/stats"
+	};
+}
+var Proxies = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async countries() {
+		return this.client.call(countriesSpec());
+	}
+	async regions(country) {
+		return this.client.call(regionsSpec(country));
+	}
+	async cities(country, region) {
+		return this.client.call(citiesSpec(country, region));
+	}
+	async quota() {
+		return this.client.call(quotaSpec());
+	}
+	async premiumStats() {
+		return this.client.call(premiumStatsSpec());
+	}
+	async sharedCountries() {
+		return this.client.call(sharedCountriesSpec());
+	}
+	async sharedQuota() {
+		return this.client.call(sharedQuotaSpec());
+	}
+	async sharedStats() {
+		return this.client.call(sharedStatsSpec());
+	}
+};
+//#endregion
+//#region src/version.ts
+const VERSION = "0.0.1";
+//#endregion
+//#region src/client.ts
+function userAgent() {
+	const bun = globalThis.Bun;
+	const runtime = bun ? `bun/${bun.version}` : `node/${process.versions.node}`;
+	return `surfsky-js/${VERSION} ${runtime}`;
+}
+function connection(apiToken, baseUrl) {
+	const token = apiToken || process.env.SURFSKY_API_TOKEN;
+	if (!token) throw new ConfigurationError("pass apiToken or set SURFSKY_API_TOKEN");
+	const url = baseUrl || process.env.SURFSKY_API_BASE_URL;
+	if (!url) throw new ConfigurationError("pass baseUrl or set SURFSKY_API_BASE_URL");
+	return {
+		baseUrl: url.replace(/\/+$/, ""),
+		headers: {
+			[AUTH_HEADER]: token,
+			Accept: "application/json",
+			"User-Agent": userAgent()
+		}
+	};
+}
+var Surfsky = class Surfsky {
+	baseUrl;
+	headers;
+	timeout;
+	maxRetries;
+	backoff;
+	logger;
+	fetch;
+	profiles;
+	proxies;
+	fingerprints;
+	extensions;
+	account;
+	constructor(options = {}) {
+		const { baseUrl, headers } = connection(options.apiToken, options.baseUrl);
+		this.baseUrl = baseUrl;
+		this.headers = {
+			...headers,
+			...options.headers
+		};
+		this.timeout = options.timeout ?? 3e4;
+		this.maxRetries = options.maxRetries ?? 3;
+		this.backoff = options.backoff ?? 500;
+		this.logger = makeLogger(options.logger);
+		this.fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+		this.profiles = new Profiles(this);
+		this.proxies = new Proxies(this);
+		this.fingerprints = new Fingerprints(this);
+		this.extensions = new Extensions(this);
+		this.account = new Account(this);
+	}
+	withOptions(options) {
+		return new Surfsky({
+			apiToken: this.headers[AUTH_HEADER],
+			baseUrl: this.baseUrl,
+			timeout: options.timeout ?? this.timeout,
+			maxRetries: options.maxRetries ?? this.maxRetries,
+			backoff: this.backoff,
+			headers: {
+				...this.headers,
+				...options.headers
+			},
+			logger: this.logger,
+			fetch: this.fetch
+		});
+	}
+	async call(spec) {
+		return result(spec, await this.#send(spec));
+	}
+	/** A raw call for endpoints the SDK does not cover. Never throws on status. */
+	request(method, path, options = {}) {
+		const spec = {
+			method,
+			path,
+			json: options.json,
+			params: options.params,
+			body: options.body,
+			timeout: options.timeout
+		};
+		return this.#send(spec, options.headers);
+	}
+	#send(spec, headers) {
+		return send(spec, {
+			fetch: this.fetch,
+			baseUrl: this.baseUrl,
+			headers: {
+				...this.headers,
+				...headers
+			},
+			retries: this.maxRetries,
+			backoff: this.backoff,
+			timeout: this.timeout,
+			logger: this.logger
+		});
+	}
+	/** Start a session; `stop()` it (or `await using`) so it does not keep billing. */
+	async session(options = {}) {
+		const { profileUuid, ...rest } = options;
+		const session = profileUuid === void 0 ? await this.profiles.startOneTime(rest) : await this.profiles.start(profileUuid, rest);
+		let stopping;
+		const stop = () => {
+			stopping ??= stopSession(this, session.internal_uuid);
+			return stopping;
+		};
+		return {
+			...session,
+			stop,
+			[Symbol.asyncDispose]: stop
+		};
+	}
+	/** Start a session and connect a `Browser` to it. `close()` stops the session. */
+	async browser(options = {}) {
+		const { profileUuid, blockResources, blockUrls, connectTimeout, commandTimeout, createWebSocket, ...sessionOptions } = options;
+		const blocked = normalizeBlocked(blockResources);
+		const urls = normalizeUrls(blockUrls);
+		const session = await this.session({
+			profileUuid,
+			...sessionOptions
+		});
+		const browser = new Browser(session, {
+			blockResources: blocked,
+			blockUrls: urls,
+			connectTimeout,
+			commandTimeout,
+			createWebSocket,
+			logger: this.logger,
+			onClose: () => session.stop()
+		});
+		await browser.connect();
+		return browser;
+	}
+	/** An open `BrowserPool`. `close()` stops every browser in it. */
+	async browsers(options = {}) {
+		return new BrowserPool(this, options).open();
+	}
+	/** `browsers()` and `pool.map()` in 1 call. */
+	async map(handler, items, options = {}) {
+		const pool = await this.browsers(options);
+		try {
+			return await pool.map(handler, items);
+		} finally {
+			await pool.close();
+		}
+	}
+	/** Nothing to release with fetch; here for `await using` symmetry. */
+	async close() {}
+	[Symbol.asyncDispose]() {
+		return this.close();
+	}
+};
+//#endregion
+export { APIConnectionError, APIError, APITimeoutError, Account, Actions, AuthenticationError, BadRequestError, Browser, BrowserPool, BrowserTimeoutError, CDPClient, CDPError, CapturedResponse, ConfigurationError, ConflictError, Extensions, Fingerprints, ForbiddenError, Keyboard, MonthlySessionLimitError, Mouse, NotFoundError, Page, PageClosedError, PaymentRequiredError, PremiumTrafficLimitError, Profiles, Proxies, ProxyCycle, ProxyRandom, ProxyTemplate, RESOURCE_TYPES, RateLimitError, ServerError, SharedTrafficLimitError, StopRun, Surfsky, SurfskyError, VERSION, ValidationError };