agents 0.27.0 → 0.28.0

package/dist/session-store-Do4xkDcf.js

@@ -0,0 +1,606 @@
+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 { Validator } from "@cfworker/json-schema";
+//#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 = /* @__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, 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, 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, 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, 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(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/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/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
+export { CdpConnection as _, applyLiveViewMode as a, connectUrl as b, BrowserRenderingError as c, createBrowserSession as d, deleteBrowserSession as f, CDP_METHOD_NOT_FOUND as g, listBrowserTargets as h, LIVE_VIEW_URL_TTL_MS as i, connectBrowser as l, isMissingBrowserSession as m, DurableBrowserSessionStore as n, createLiveView as o, getBrowserRecording as p, loadCdpSpec as r, validateConnectorArgs as s, DEFAULT_SWEEP_IDLE_MS as t, connectBrowserSession as u, CdpProtocolError as v, CdpSession as y };
+
+//# sourceMappingURL=session-store-Do4xkDcf.js.map