agents 0.27.0 → 0.28.0

package/dist/{connector-58XDGvc3.js → connector-CtZylXdk.js}

@@ -1,391 +1,7 @@
 import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
 import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
+import { a as applyLiveViewMode, b as connectUrl, c as BrowserRenderingError, d as createBrowserSession, f as deleteBrowserSession, h as listBrowserTargets, i as LIVE_VIEW_URL_TTL_MS, l as connectBrowser, o as createLiveView, r as loadCdpSpec, s as validateConnectorArgs, u as connectBrowserSession, v as CdpProtocolError } from "./session-store-Do4xkDcf.js";
 import { CodemodeConnector } from "@cloudflare/codemode";
-import { Validator } from "@cfworker/json-schema";
-//#region src/browser/connector-validation.ts
-function formatToolValidationError(connector, tool, errors) {
-	const specific = errors.filter((error) => error.keyword !== "properties");
-	return `Invalid arguments for ${connector}.${tool}${(specific.length > 0 ? specific : errors).map((error) => {
-		const location = error.instanceLocation.replace(/^#\/?/, "").replaceAll("~1", "/").replaceAll("~0", "~").replaceAll("/", ".");
-		return `${location ? ` at ${location}` : ""}: ${error.error}`;
-	}).join(";")}`;
-}
-/**
-* Validate a connector tool's arguments against its input schema before it
-* runs, so the model gets a precise error instead of a failure deep inside
-* browser work. An omitted argument counts as `{}`: argumentless tools are
-* documented as `cdp.spec()`.
-*/
-function validateConnectorArgs(connector, name, tool) {
-	if (!tool.inputSchema) return tool;
-	const schema = tool.inputSchema;
-	const validator = new Validator(schema, "7", false);
-	return {
-		...tool,
-		execute: async (args, ctx) => {
-			const input = args === void 0 ? {} : args;
-			const result = validator.validate(input);
-			if (!result.valid) throw new Error(formatToolValidationError(connector, name, result.errors));
-			return await tool.execute(input, ctx);
-		}
-	};
-}
-//#endregion
-//#region src/browser/cdp-connection.ts
-const DEFAULT_TIMEOUT_MS = 1e4;
-/** JSON-RPC's "method not found" code, which Chrome also uses for CDP. */
-const CDP_METHOD_NOT_FOUND = -32601;
-/** The browser answered a command with a JSON-RPC error. */
-var CdpProtocolError = class extends Error {
-	constructor(method, code, message) {
-		super(`CDP error ${code ?? "unknown"}: ${message} for ${method}`);
-		this.name = "CdpProtocolError";
-		this.code = code;
-		this.method = method;
-	}
-};
-const MAX_DEBUG_ENTRIES = 400;
-var _socket$1 = /* @__PURE__ */ new WeakMap();
-var _nextId = /* @__PURE__ */ new WeakMap();
-var _pending = /* @__PURE__ */ new WeakMap();
-var _debugLog = /* @__PURE__ */ new WeakMap();
-var _defaultTimeoutMs = /* @__PURE__ */ new WeakMap();
-var _dispose = /* @__PURE__ */ new WeakMap();
-var _disposed = /* @__PURE__ */ new WeakMap();
-var _onActivity = /* @__PURE__ */ new WeakMap();
-var _CdpConnection_brand = /* @__PURE__ */ new WeakSet();
-/**
-* One Chrome DevTools Protocol connection over an open WebSocket. Manages
-* command correlation, timeouts, per-tab CDP sessions, and a debug event
-* ring buffer.
-*
-* Used host-side (not in the sandbox) — the sandbox calls into this
-* via DynamicWorkerExecutor's ToolDispatcher RPC.
-*/
-var CdpConnection = class {
-	constructor(socket, optionsOrTimeoutMs, onClose, sessionId) {
-		_classPrivateMethodInitSpec(this, _CdpConnection_brand);
-		_classPrivateFieldInitSpec(this, _socket$1, void 0);
-		_classPrivateFieldInitSpec(this, _nextId, 1);
-		_classPrivateFieldInitSpec(this, _pending, /* @__PURE__ */ new Map());
-		_classPrivateFieldInitSpec(this, _debugLog, []);
-		_classPrivateFieldInitSpec(this, _defaultTimeoutMs, void 0);
-		_classPrivateFieldInitSpec(this, _dispose, void 0);
-		_classPrivateFieldInitSpec(this, _disposed, false);
-		_classPrivateFieldInitSpec(this, _onActivity, void 0);
-		const options = typeof optionsOrTimeoutMs === "object" ? optionsOrTimeoutMs : {
-			timeoutMs: optionsOrTimeoutMs,
-			onClose,
-			sessionId
-		};
-		_classPrivateFieldSet2(_socket$1, this, socket);
-		_classPrivateFieldSet2(_defaultTimeoutMs, this, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-		_classPrivateFieldSet2(_dispose, this, options.onClose);
-		this.sessionId = options.sessionId;
-		_classPrivateFieldSet2(_onActivity, this, options.onActivity);
-		socket.addEventListener("message", (event) => _assertClassBrand(_CdpConnection_brand, this, _handleMessage).call(this, event));
-		socket.addEventListener("error", () => {
-			_assertClassBrand(_CdpConnection_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP socket error"));
-			_assertClassBrand(_CdpConnection_brand, this, _runDispose).call(this);
-		});
-		socket.addEventListener("close", () => {
-			_assertClassBrand(_CdpConnection_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP connection closed"));
-			_assertClassBrand(_CdpConnection_brand, this, _runDispose).call(this);
-		});
-	}
-	send(method, params, options = {}) {
-		var _this$nextId, _this$nextId2;
-		_classPrivateFieldGet2(_onActivity, this)?.call(this);
-		const id = (_classPrivateFieldSet2(_nextId, this, (_this$nextId = _classPrivateFieldGet2(_nextId, this), _this$nextId2 = _this$nextId++, _this$nextId)), _this$nextId2);
-		const timeoutMs = options.timeoutMs ?? _classPrivateFieldGet2(_defaultTimeoutMs, this);
-		const sessionId = typeof options.sessionId === "string" && options.sessionId.length > 0 ? options.sessionId : void 0;
-		const domain = typeof method === "string" ? method.split(".")[0] : "";
-		if (!sessionId && domain && !["Browser", "Target"].includes(domain)) _assertClassBrand(_CdpConnection_brand, this, _recordDebug).call(this, "warning", {
-			id,
-			method,
-			reason: "target-scoped method sent without sessionId"
-		});
-		const result = new Promise((resolve, reject) => {
-			const startedAt = performance.now();
-			const timeoutId = setTimeout(() => {
-				_classPrivateFieldGet2(_pending, this).delete(id);
-				reject(/* @__PURE__ */ new Error(`CDP command timed out after ${timeoutMs}ms: ${method}`));
-			}, timeoutMs);
-			_classPrivateFieldGet2(_pending, this).set(id, {
-				resolve,
-				reject,
-				timeoutId,
-				method,
-				sessionId,
-				startedAt
-			});
-		});
-		_assertClassBrand(_CdpConnection_brand, this, _recordDebug).call(this, "send", {
-			id,
-			method,
-			sessionId,
-			timeoutMs
-		});
-		try {
-			_classPrivateFieldGet2(_socket$1, this).send(JSON.stringify({
-				id,
-				method,
-				params,
-				sessionId
-			}));
-		} catch (error) {
-			const pending = _classPrivateFieldGet2(_pending, this).get(id);
-			if (pending) {
-				clearTimeout(pending.timeoutId);
-				_classPrivateFieldGet2(_pending, this).delete(id);
-				pending.reject(error instanceof Error ? error : new Error(String(error)));
-			}
-		}
-		return result;
-	}
-	async attachToTarget(targetId, options = {}) {
-		if (typeof targetId !== "string" || !targetId) throw new Error("attachToTarget requires a targetId — list open tabs with send('Target.getTargets') or create one with send('Target.createTarget', { url })");
-		const sessionId = (await this.send("Target.attachToTarget", {
-			targetId,
-			flatten: true
-		}, { timeoutMs: options.timeoutMs }))?.sessionId ?? "";
-		if (!sessionId) throw new Error(`Target.attachToTarget did not return a sessionId for target ${targetId}`);
-		_assertClassBrand(_CdpConnection_brand, this, _recordDebug).call(this, "attach", {
-			targetId,
-			sessionId
-		});
-		return sessionId;
-	}
-	getDebugLog(limit = 50) {
-		const normalized = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 50;
-		return _classPrivateFieldGet2(_debugLog, this).slice(-normalized);
-	}
-	clearDebugLog() {
-		_classPrivateFieldSet2(_debugLog, this, []);
-	}
-	disconnect() {
-		_assertClassBrand(_CdpConnection_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP session disconnected"));
-		try {
-			_classPrivateFieldGet2(_socket$1, this).close(1e3, "Done");
-		} catch {}
-	}
-	close() {
-		this.disconnect();
-		_assertClassBrand(_CdpConnection_brand, this, _runDispose).call(this);
-	}
-};
-/**
-* Run the dispose callback exactly once, on the first terminal event —
-* an explicit {@link close}, peer closure, or a socket error.
-*/
-function _runDispose() {
-	if (_classPrivateFieldGet2(_disposed, this)) return;
-	_classPrivateFieldSet2(_disposed, this, true);
-	_classPrivateFieldGet2(_dispose, this)?.call(this);
-}
-function _rejectAll(error) {
-	for (const [id, pending] of _classPrivateFieldGet2(_pending, this).entries()) {
-		clearTimeout(pending.timeoutId);
-		_classPrivateFieldGet2(_pending, this).delete(id);
-		pending.reject(error);
-	}
-}
-function _handleMessage(event) {
-	if (typeof event.data !== "string") return;
-	let payload;
-	try {
-		payload = JSON.parse(event.data);
-	} catch {
-		return;
-	}
-	_assertClassBrand(_CdpConnection_brand, this, _recordDebug).call(this, "receive", {
-		id: payload.id,
-		method: payload.method,
-		sessionId: payload.sessionId,
-		hasError: !!payload.error
-	});
-	if (typeof payload.id !== "number") return;
-	const pending = _classPrivateFieldGet2(_pending, this).get(payload.id);
-	if (!pending) return;
-	clearTimeout(pending.timeoutId);
-	_classPrivateFieldGet2(_pending, this).delete(payload.id);
-	if (payload.error) {
-		const err = payload.error;
-		pending.reject(new CdpProtocolError(pending.method, typeof err.code === "number" ? err.code : void 0, err.message ?? "CDP error"));
-		return;
-	}
-	pending.resolve(payload.result);
-}
-function _recordDebug(type, data) {
-	_classPrivateFieldGet2(_debugLog, this).push({
-		at: (/* @__PURE__ */ new Date()).toISOString(),
-		type,
-		...data
-	});
-	if (_classPrivateFieldGet2(_debugLog, this).length > MAX_DEBUG_ENTRIES) _classPrivateFieldGet2(_debugLog, this).splice(0, _classPrivateFieldGet2(_debugLog, this).length - MAX_DEBUG_ENTRIES);
-}
-const LOCALHOST_HOSTS = /* @__PURE__ */ new Set([
-	"localhost",
-	"127.0.0.1",
-	"0.0.0.0",
-	"::1",
-	"[::1]"
-]);
-/**
-* Connect to a browser via a CDP base URL (e.g. http://localhost:9222).
-* Discovers the WebSocket debugger URL via /json/version,
-* rewrites localhost URLs to the base URL host, and opens the WebSocket.
-*
-* Useful for local development with `chrome --remote-debugging-port=9222`
-* or when connecting through a tunnel.
-*/
-async function connectUrl(baseUrl, options) {
-	const endpoint = new URL("/json/version", baseUrl).toString();
-	const response = await fetch(endpoint, { headers: options?.headers });
-	if (!response.ok) throw new Error(`Failed to discover CDP endpoint at ${endpoint}: ${response.status}`);
-	const payload = await response.json();
-	if (!payload.webSocketDebuggerUrl) throw new Error("CDP /json/version did not include webSocketDebuggerUrl");
-	let wsUrl = payload.webSocketDebuggerUrl;
-	const parsed = new URL(wsUrl);
-	if (LOCALHOST_HOSTS.has(parsed.hostname)) {
-		const base = new URL(baseUrl);
-		parsed.hostname = base.hostname;
-		parsed.port = base.port;
-		parsed.protocol = base.protocol;
-	} else parsed.protocol = parsed.protocol === "wss:" ? "https:" : "http:";
-	const fetchUrl = parsed.toString();
-	const wsResponse = await fetch(fetchUrl, { headers: {
-		...options?.headers,
-		Upgrade: "websocket"
-	} });
-	const ws = wsResponse.webSocket;
-	if (!ws) throw new Error(`Failed to establish CDP WebSocket at ${fetchUrl} (status ${wsResponse.status})`);
-	ws.accept();
-	return new CdpConnection(ws, { timeoutMs: options?.timeoutMs });
-}
-/** @deprecated Renamed to {@link CdpConnection}. */
-const CdpSession = CdpConnection;
-//#endregion
-//#region src/browser/browser-run.ts
-var BrowserRenderingError = class extends Error {
-	constructor(message, status) {
-		super(message);
-		this.status = status;
-		this.name = "BrowserRenderingError";
-	}
-};
-/**
-* Whether an error means the platform session is gone: Browser Run uses 404
-* for unknown ids and 410 after `keep_alive` expiry.
-*/
-function isMissingBrowserSession$1(error) {
-	return error instanceof BrowserRenderingError && (error.status === 404 || error.status === 410);
-}
-function browserSessionEndpoint(sessionId, options) {
-	const path = sessionId ? `/v1/devtools/browser/${sessionId}` : "/v1/devtools/browser";
-	const url = new URL(`https://localhost${path}`);
-	if (options?.keepAliveMs !== void 0) url.searchParams.set("keep_alive", String(options.keepAliveMs));
-	if (options?.includeTargets) url.searchParams.set("targets", "true");
-	if (options?.recording) url.searchParams.set("recording", "true");
-	if (options?.browser) url.searchParams.set("browser", options.browser);
-	return url.toString();
-}
-async function parseBrowserSessionInfo(response) {
-	const payload = await response.json();
-	const sessionId = typeof payload.sessionId === "string" ? payload.sessionId : "";
-	if (!sessionId) throw new Error("Browser Rendering response did not include a sessionId");
-	return {
-		sessionId,
-		targets: Array.isArray(payload.targets) ? payload.targets : void 0,
-		webSocketDebuggerUrl: typeof payload.webSocketDebuggerUrl === "string" ? payload.webSocketDebuggerUrl : void 0
-	};
-}
-async function createBrowserSession(browser, options) {
-	const response = await browser.fetch(browserSessionEndpoint(void 0, options), {
-		method: "POST",
-		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify(options?.guardrails ? { guardrails: options.guardrails } : {})
-	});
-	if (!response.ok) throw new BrowserRenderingError(`Failed to create Browser Rendering session: ${response.status}`, response.status);
-	return parseBrowserSessionInfo(response);
-}
-async function listBrowserTargets(browser, sessionId) {
-	const response = await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}/json/list`);
-	if (!response.ok) throw new BrowserRenderingError(`Failed to list Browser Rendering targets for ${sessionId}: ${response.status}`, response.status);
-	const payload = await response.json();
-	return Array.isArray(payload) ? payload : [];
-}
-async function deleteBrowserSession(browser, sessionId) {
-	const response = await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}`, { method: "DELETE" });
-	if (!response.ok && response.status !== 404) throw new BrowserRenderingError(`Failed to delete Browser Rendering session ${sessionId}: ${response.status}`, response.status);
-}
-/**
-* Connect to a Browser Rendering session and delete it when closed.
-*/
-async function connectBrowser(browser, options) {
-	const normalizedOptions = typeof options === "number" ? { timeoutMs: options } : options ?? {};
-	if (normalizedOptions.browser === "kitesurf") {
-		const smuggled = normalizedOptions;
-		if (smuggled.keepAliveMs || smuggled.includeTargets || smuggled.recording) throw new Error("Kitesurf does not support keepAliveMs, includeTargets, or recording");
-	}
-	const response = await browser.fetch(browserSessionEndpoint(void 0, normalizedOptions.browser === "kitesurf" ? { browser: "kitesurf" } : {
-		keepAliveMs: normalizedOptions.keepAliveMs,
-		includeTargets: normalizedOptions.includeTargets,
-		recording: normalizedOptions.recording
-	}), { headers: { Upgrade: "websocket" } });
-	const ws = response.webSocket;
-	if (!ws) throw new Error("Browser Rendering binding did not return a WebSocket. Ensure the 'browser' binding is configured in wrangler.jsonc.");
-	if (normalizedOptions.browser === "kitesurf") {
-		ws.accept();
-		return new CdpConnection(ws, { timeoutMs: normalizedOptions.timeoutMs });
-	}
-	const sessionId = response.headers.get("cf-browser-session-id");
-	if (!sessionId) throw new Error("Browser Rendering binding did not include a session ID when opening the CDP WebSocket");
-	ws.accept();
-	return new CdpConnection(ws, {
-		timeoutMs: normalizedOptions.timeoutMs,
-		onClose: () => {
-			deleteBrowserSession(browser, sessionId).catch((error) => {
-				console.warn(`[agents/browser] Failed to delete one-shot Browser Run session ${sessionId}`, error);
-			});
-		},
-		sessionId
-	});
-}
-/**
-* Fetch a Browser Run [session recording](https://developers.cloudflare.com/browser-run/features/session-recording/)
-* by session id, via the Browser Rendering REST API.
-*
-* A recording is only available **after** the session closes (explicit
-* `closeSession()`, idle `keep_alive` expiry, or sweep) and is retained for 30
-* days. Capture the session id while the session is alive — e.g. from
-* `connector.liveView()`/`sessionInfo()` — then call this once it has ended.
-*
-* Unlike the binding-based helpers, this hits `api.cloudflare.com` directly, so
-* it needs an account id and an API token with `Browser Rendering` read access
-* (the Workers Browser Run binding cannot read recordings).
-*/
-async function getBrowserRecording(options) {
-	const { accountId, apiToken, sessionId } = options;
-	const response = await (options.fetchImpl ?? fetch)(`https://api.cloudflare.com/client/v4/accounts/${accountId}/browser-rendering/recording/${sessionId}`, { headers: { Authorization: `Bearer ${apiToken}` } });
-	if (!response.ok) throw new BrowserRenderingError(`Failed to fetch Browser Run recording for ${sessionId}: ${response.status}`, response.status);
-	const payload = await response.json();
-	return "result" in payload && payload.result ? payload.result : payload;
-}
-async function connectBrowserSession(browser, sessionId, options) {
-	const normalized = typeof options === "number" ? { timeoutMs: options } : options ?? {};
-	const response = await browser.fetch(browserSessionEndpoint(sessionId), { headers: { Upgrade: "websocket" } });
-	const ws = response.webSocket;
-	if (!ws) throw new BrowserRenderingError(`Browser Rendering binding did not return a WebSocket for session ${sessionId} (${response.status})`, response.status);
-	ws.accept();
-	return new CdpConnection(ws, {
-		timeoutMs: normalized.timeoutMs,
-		onClose: normalized.onClose,
-		sessionId,
-		onActivity: normalized.onActivity
-	});
-}
-//#endregion
 //#region src/browser/quick-actions.ts
 function runQuickAction(browser, action, params) {
 	return browser.quickAction(action, params);
@@ -467,222 +83,6 @@ function browserPdf(browser, input) {
 	return quickActionBinary(browser, "pdf", input);
 }
 //#endregion
-//#region src/browser/live-view.ts
-/**
-* Browser Run mints `devtoolsFrontendUrl`s (the Live View links) that are
-* valid for ~5 minutes. We surface the window so callers can decide how long
-* a shared link is good for before re-listing targets.
-*/
-const LIVE_VIEW_URL_TTL_MS = 300 * 1e3;
-/**
-* Rewrite the hosted Live View UI's `mode` query param (`tab` | `devtools`).
-* The raw `devtoolsFrontendUrl` is returned unchanged when no mode is asked
-* for or the URL can't be parsed.
-*/
-function applyLiveViewMode(rawUrl, mode) {
-	if (!mode) return rawUrl;
-	try {
-		const url = new URL(rawUrl);
-		url.searchParams.set("mode", mode === "devtools" ? "devtools" : "tab");
-		return url.toString();
-	} catch {
-		return rawUrl;
-	}
-}
-/**
-* Project a fresh target listing into Live View links — one per tab that has
-* a `devtoolsFrontendUrl`. Pure; the caller supplies just-listed targets.
-*/
-function createLiveView(sessionId, targets, mode) {
-	return {
-		sessionId,
-		targets: targets.filter((target) => target.devtoolsFrontendUrl).map((target) => ({
-			targetId: target.id,
-			url: applyLiveViewMode(target.devtoolsFrontendUrl, mode),
-			pageUrl: target.url,
-			title: target.title,
-			type: target.type
-		})),
-		expiresInMs: LIVE_VIEW_URL_TTL_MS
-	};
-}
-//#endregion
-//#region src/browser/spec.ts
-const MISSING_BROWSER_CONFIG = "Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided";
-const urlSpecCache = /* @__PURE__ */ new Map();
-const bindingSpecCache = /* @__PURE__ */ new WeakMap();
-const CACHE_TTL_MS = 300 * 1e3;
-/** Qualify a same-domain `$ref` (`"FrameId"` → `"Page.FrameId"`). */
-function qualifyRef(domain, ref) {
-	if (ref === void 0) return void 0;
-	return ref.includes(".") ? ref : `${domain}.${ref}`;
-}
-function normalizeItems(domain, items) {
-	if (!items) return void 0;
-	return {
-		type: items.type,
-		$ref: qualifyRef(domain, items.$ref),
-		enum: items.enum
-	};
-}
-function normalizeFields(domain, fields) {
-	return (fields ?? []).map((field) => ({
-		name: field.name,
-		description: field.description,
-		optional: field.optional,
-		experimental: field.experimental,
-		deprecated: field.deprecated,
-		type: field.type,
-		$ref: qualifyRef(domain, field.$ref),
-		enum: field.enum,
-		items: normalizeItems(domain, field.items)
-	}));
-}
-function normalizeCdpSpec(spec) {
-	return { domains: (spec.domains ?? []).map(({ domain, ...raw }) => ({
-		name: domain,
-		description: raw.description,
-		experimental: raw.experimental,
-		deprecated: raw.deprecated,
-		commands: (raw.commands ?? []).map((command) => ({
-			name: command.name,
-			method: `${domain}.${command.name}`,
-			description: command.description,
-			experimental: command.experimental,
-			deprecated: command.deprecated,
-			parameters: normalizeFields(domain, command.parameters),
-			returns: normalizeFields(domain, command.returns)
-		})),
-		events: (raw.events ?? []).map((event) => ({
-			name: event.name,
-			event: `${domain}.${event.name}`,
-			description: event.description,
-			experimental: event.experimental,
-			deprecated: event.deprecated,
-			parameters: normalizeFields(domain, event.parameters)
-		})),
-		types: (raw.types ?? []).map((type) => ({
-			id: type.id,
-			name: `${domain}.${type.id}`,
-			description: type.description,
-			experimental: type.experimental,
-			deprecated: type.deprecated,
-			type: type.type,
-			enum: type.enum,
-			properties: normalizeFields(domain, type.properties),
-			items: normalizeItems(domain, type.items)
-		}))
-	})) };
-}
-function getSpecCacheKey(source, headers) {
-	const headerEntries = Object.entries(headers ?? {}).sort(([a], [b]) => a.localeCompare(b));
-	return `${source}:${JSON.stringify(headerEntries)}`;
-}
-async function getCachedSpec(cache, key, load) {
-	const cached = cache.get(key);
-	if (cached && Date.now() - cached.cachedAt < CACHE_TTL_MS) return cached.spec;
-	const spec = normalizeCdpSpec(await load());
-	cache.set(key, {
-		spec,
-		cachedAt: Date.now()
-	});
-	return spec;
-}
-async function fetchCdpSpecFromUrl(cdpBaseUrl, headers) {
-	const endpoint = new URL("/json/protocol", cdpBaseUrl).toString();
-	return getCachedSpec(urlSpecCache, getSpecCacheKey(endpoint, headers), async () => {
-		const response = await fetch(endpoint, { headers });
-		if (!response.ok) throw new Error(`Failed to fetch CDP spec from ${endpoint}: ${response.status}`);
-		return await response.json();
-	});
-}
-async function fetchCdpSpecFromSession(browser, sessionId) {
-	return getCachedSpec(bindingSpecCache, browser, async () => {
-		const response = await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}/json/protocol`);
-		if (!response.ok) throw new Error(`Failed to fetch CDP spec from Browser Rendering: ${response.status}`);
-		return await response.json();
-	});
-}
-async function fetchCdpSpecFromBrowser(browser) {
-	return getCachedSpec(bindingSpecCache, browser, async () => {
-		const createResponse = await browser.fetch("https://localhost/v1/devtools/browser", { method: "POST" });
-		if (!createResponse.ok) throw new Error(`Failed to create Browser Rendering session for protocol fetch: ${createResponse.status}`);
-		const sessionId = (await createResponse.json()).sessionId;
-		if (!sessionId) throw new Error("Browser Rendering session response did not include a sessionId");
-		try {
-			const response = await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}/json/protocol`);
-			if (!response.ok) throw new Error(`Failed to fetch CDP spec from Browser Rendering: ${response.status}`);
-			return await response.json();
-		} finally {
-			try {
-				await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}`, { method: "DELETE" });
-			} catch {}
-		}
-	});
-}
-/** Load the (cached) searchable CDP spec for a browser source. */
-async function loadCdpSpec(source) {
-	if (source.cdpUrl) return fetchCdpSpecFromUrl(source.cdpUrl, source.cdpHeaders);
-	if (source.browser && source.sessionId) return fetchCdpSpecFromSession(source.browser, source.sessionId);
-	if (source.browser) return fetchCdpSpecFromBrowser(source.browser);
-	throw new Error(MISSING_BROWSER_CONFIG);
-}
-//#endregion
-//#region src/browser/session-store.ts
-var _DurableBrowserSessionStore_brand = /* @__PURE__ */ new WeakSet();
-var DurableBrowserSessionStore = class {
-	constructor(storage) {
-		this.storage = storage;
-		_classPrivateMethodInitSpec(this, _DurableBrowserSessionStore_brand);
-	}
-	async acquireLock(key) {
-		let queues = _queues._.get(this.storage);
-		if (!queues) {
-			queues = /* @__PURE__ */ new Map();
-			_queues._.set(this.storage, queues);
-		}
-		const previous = queues.get(key) ?? Promise.resolve();
-		let releaseQueue = () => void 0;
-		const current = previous.then(() => new Promise((resolve) => {
-			releaseQueue = resolve;
-		}));
-		queues.set(key, current);
-		await previous;
-		let released = false;
-		return { release: () => {
-			if (released) return;
-			released = true;
-			if (queues.get(key) === current) queues.delete(key);
-			releaseQueue();
-		} };
-	}
-	async get(key) {
-		return this.storage.get(_assertClassBrand(_DurableBrowserSessionStore_brand, this, _storageKey).call(this, key));
-	}
-	async set(key, session) {
-		await this.storage.put(_assertClassBrand(_DurableBrowserSessionStore_brand, this, _storageKey).call(this, key), session);
-	}
-	async delete(key) {
-		await this.storage.delete(_assertClassBrand(_DurableBrowserSessionStore_brand, this, _storageKey).call(this, key));
-	}
-	async list(prefix) {
-		const storagePrefix = _assertClassBrand(_DurableBrowserSessionStore_brand, this, _storageKey).call(this, prefix);
-		const entries = await this.storage.list({ prefix: storagePrefix });
-		const result = /* @__PURE__ */ new Map();
-		for (const [storageKey, value] of entries) result.set(storageKey.slice(16), value);
-		return result;
-	}
-};
-function _storageKey(key) {
-	return `browser-session:${key}`;
-}
-var _queues = { _: /* @__PURE__ */ new WeakMap() };
-/**
-* Default idle window used by {@link BrowserConnector.sweep} for the shared
-* (reuse/promoted) session entry.
-*/
-const DEFAULT_SWEEP_IDLE_MS = 600 * 1e3;
-//#endregion
 //#region src/browser/connector.ts
 const EXEC_KEY_PREFIX = "cdp:exec:";
 /**
@@ -1535,6 +935,6 @@ async function _closeStoredSession(key) {
 	if (stored) await deleteBrowserSession(browser, stored.sessionId);
 }
 //#endregion
-export { listBrowserTargets as C, CdpSession as D, CdpProtocolError as E, connectUrl as O, isMissingBrowserSession$1 as S, CdpConnection as T, connectBrowser as _, loadCdpSpec as a, deleteBrowserSession as b, browserExtract as c, browserPdf as d, browserScrape as f, BrowserRenderingError as g, runQuickAction as h, DurableBrowserSessionStore as i, validateConnectorArgs as k, browserLinks as l, browserSnapshot as m, DEFAULT_EXEC_SWEEP_IDLE_MS as n, createLiveView as o, browserScreenshot as p, DEFAULT_SWEEP_IDLE_MS as r, browserContent as s, BrowserConnector as t, browserMarkdown as u, connectBrowserSession as v, CDP_METHOD_NOT_FOUND as w, getBrowserRecording as x, createBrowserSession as y };
+export { browserLinks as a, browserScrape as c, runQuickAction as d, browserExtract as i, browserScreenshot as l, DEFAULT_EXEC_SWEEP_IDLE_MS as n, browserMarkdown as o, browserContent as r, browserPdf as s, BrowserConnector as t, browserSnapshot as u };
 
-//# sourceMappingURL=connector-58XDGvc3.js.map
+//# sourceMappingURL=connector-CtZylXdk.js.map