agents 0.14.5 → 0.16.0

package/dist/connector-D6yYzYHg.js

@@ -0,0 +1,1080 @@
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-CZ7QjTXN.js";
+import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-D-0__zd9.js";
+import { CodemodeConnector } from "@cloudflare/codemode";
+//#region src/browser/cdp-session.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+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 _CdpSession_brand = /* @__PURE__ */ new WeakSet();
+/**
+* A CDP session over an open WebSocket. Manages command correlation,
+* timeouts, target 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 CdpSession = class {
+	constructor(socket, defaultTimeoutMs = DEFAULT_TIMEOUT_MS, dispose, sessionId) {
+		_classPrivateMethodInitSpec(this, _CdpSession_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);
+		_classPrivateFieldSet2(_socket$1, this, socket);
+		_classPrivateFieldSet2(_defaultTimeoutMs, this, defaultTimeoutMs);
+		_classPrivateFieldSet2(_dispose, this, dispose);
+		this.sessionId = sessionId;
+		socket.addEventListener("message", (event) => _assertClassBrand(_CdpSession_brand, this, _handleMessage).call(this, event));
+		socket.addEventListener("error", () => {
+			_assertClassBrand(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP socket error"));
+		});
+		socket.addEventListener("close", () => {
+			_assertClassBrand(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP connection closed"));
+		});
+	}
+	send(method, params, options = {}) {
+		var _this$nextId, _this$nextId2;
+		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(_CdpSession_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(_CdpSession_brand, this, _recordDebug).call(this, "send", {
+			id,
+			method,
+			sessionId,
+			timeoutMs
+		});
+		_classPrivateFieldGet2(_socket$1, this).send(JSON.stringify({
+			id,
+			method,
+			params,
+			sessionId
+		}));
+		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(_CdpSession_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(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP session disconnected"));
+		try {
+			_classPrivateFieldGet2(_socket$1, this).close(1e3, "Done");
+		} catch {}
+	}
+	close() {
+		this.disconnect();
+		_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(_CdpSession_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;
+		const code = err.code ?? "unknown";
+		const message = err.message ?? "CDP error";
+		pending.reject(/* @__PURE__ */ new Error(`CDP error ${code}: ${message} for ${pending.method}`));
+		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 = 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 CdpSession(ws, options?.timeoutMs);
+}
+//#endregion
+//#region src/browser/browser-run.ts
+var BrowserRenderingError = class extends Error {
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		this.name = "BrowserRenderingError";
+	}
+};
+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");
+	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" });
+	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 ?? {};
+	const response = await browser.fetch(browserSessionEndpoint(void 0, {
+		keepAliveMs: normalizedOptions.keepAliveMs,
+		includeTargets: normalizedOptions.includeTargets
+	}), { 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.");
+	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 CdpSession(ws, normalizedOptions.timeoutMs, () => {
+		deleteBrowserSession(browser, sessionId).catch((error) => {
+			console.warn(`[agents/browser] Failed to delete one-shot Browser Run session ${sessionId}`, error);
+		});
+	}, sessionId);
+}
+/**
+* Connect to an existing Browser Rendering session without deleting it on close.
+*/
+async function connectBrowserSession(browser, sessionId, timeoutMs) {
+	const ws = (await browser.fetch(browserSessionEndpoint(sessionId), { headers: { Upgrade: "websocket" } })).webSocket;
+	if (!ws) throw new Error(`Browser Rendering binding did not return a WebSocket for session ${sessionId}`);
+	ws.accept();
+	return new CdpSession(ws, timeoutMs, void 0, sessionId);
+}
+//#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;
+function normalizeCdpSpec(spec) {
+	return { domains: (spec.domains ?? []).map((domain) => ({
+		name: domain.domain,
+		description: domain.description,
+		commands: (domain.commands ?? []).map((command) => ({
+			name: command.name,
+			method: `${domain.domain}.${command.name}`,
+			description: command.description
+		})),
+		events: (domain.events ?? []).map((event) => ({
+			name: event.name,
+			event: `${domain.domain}.${event.name}`,
+			description: event.description
+		})),
+		types: (domain.types ?? []).map((type) => ({
+			id: type.id,
+			name: `${domain.domain}.${type.id}`,
+			description: type.description
+		}))
+	})) };
+}
+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 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) return fetchCdpSpecFromBrowser(source.browser);
+	throw new Error(MISSING_BROWSER_CONFIG);
+}
+//#endregion
+//#region src/browser/session-manager.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:";
+const REUSE_KEY_PREFIX = "cdp:reuse:";
+/**
+* Default idle window before {@link BrowserConnector.sweep} reclaims a
+* per-execution session. Matches the codemode runtime's default paused TTL
+* (24h): an execution paused for approval keeps its browser until the run
+* itself is expired.
+*/
+const DEFAULT_EXEC_SWEEP_IDLE_MS = 1440 * 60 * 1e3;
+/**
+* Minimum interval between `updatedAt` bumps on a per-execution store entry.
+* Touching on every CDP call would write-amplify; once a minute is enough to
+* keep an active or recently-resumed execution out of sweep range.
+*/
+const EXEC_TOUCH_INTERVAL_MS = 60 * 1e3;
+function isMissingBrowserSession(error) {
+	return error instanceof BrowserRenderingError && error.status === 404;
+}
+/**
+* `cdp.attachToTarget` returns `{ sessionId: "target:<targetId>" }` — a stable
+* handle instead of the raw CDP session id. (The object shape mirrors the real
+* `Target.attachToTarget` response, which is what models reach for.) Raw ids
+* are connection-scoped: a run that pauses
+* for approval resumes on a fresh WebSocket where the old id is invalid, and
+* the durable replay log would otherwise pin the stale value. The handle is a
+* pure function of the target, so replayed code computes identical arguments,
+* and `send` resolves it to a live session id on the current socket —
+* re-attaching lazily after a reconnect.
+*/
+const ATTACH_HANDLE_PREFIX = "target:";
+var _options = /* @__PURE__ */ new WeakMap();
+var _sockets = /* @__PURE__ */ new WeakMap();
+var _connecting = /* @__PURE__ */ new WeakMap();
+var _BrowserConnector_brand = /* @__PURE__ */ new WeakSet();
+/**
+* Codemode connector exposing a live browser over the Chrome DevTools
+* Protocol as the `cdp` global.
+*
+* Per-execution resources are keyed by the codemode `executionId`:
+*
+* - The Browser Run session id is stored durably under `cdp:exec:<id>`, so a
+*   run that pauses for approval reconnects to the *same* browser when it
+*   resumes — even on a fresh instance.
+* - The CDP WebSocket is per-pass: `onPassEnd` disconnects it (a paused run
+*   holds no socket), and the next pass reconnects from the stored id.
+* - `disposeExecution` deletes the session unless it was promoted to the
+*   shared slot via `cdp.startSession()` (dynamic mode).
+*
+* Locks on the session store are held only around store reads/writes, never
+* across network calls to Browser Run or while a socket is open.
+*/
+var BrowserConnector = class extends CodemodeConnector {
+	constructor(ctx, options) {
+		super(ctx, {});
+		_classPrivateMethodInitSpec(this, _BrowserConnector_brand);
+		_classPrivateFieldInitSpec(this, _options, void 0);
+		_classPrivateFieldInitSpec(this, _sockets, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _connecting, /* @__PURE__ */ new Map());
+		if (!options.cdpUrl && !options.browser) throw new Error("BrowserConnector requires either 'browser' (Fetcher binding) or 'cdpUrl'");
+		if (options.browser && !options.store) throw new Error("BrowserConnector requires 'store' when using the Browser Rendering binding");
+		_classPrivateFieldSet2(_options, this, options);
+	}
+	name() {
+		return "cdp";
+	}
+	instructions() {
+		const mode = _assertClassBrand(_BrowserConnector_brand, this, _mode).call(this);
+		const lines = [
+			"Issue CDP calls sequentially — never in parallel (no Promise.all): call order is recorded for durable replay.",
+			"Browser-/Target-scoped commands (Target.createTarget, Target.getTargets) need no sessionId. Page-scoped commands (Page.navigate, Runtime.evaluate) require one: `const { sessionId } = await cdp.attachToTarget({ targetId });` then pass it to every page-scoped send.",
+			"Write large outputs (screenshots, page dumps) to a file or workspace immediately and pass around small references — large return values fail to record.",
+			"Use cdp.spec() to discover commands, events, and types when unsure.",
+			"If a command fails or times out, check cdp.getDebugLog() for recent protocol traffic."
+		];
+		if (mode === "one-shot") lines.push("The browser session lasts for this execution only and is closed when it ends.");
+		else if (mode === "reuse") lines.push("The browser session is shared and persists across executions — tabs and state you leave behind will still be there next time.");
+		else lines.push("The browser session is one-shot by default. If browser state must persist after this execution (e.g. a logged-in page), call cdp.startSession() to keep it alive for later executions.");
+		return lines.join("\n");
+	}
+	tools() {
+		const tools = {
+			send: {
+				description: "Send a CDP command and return its result. Page-scoped commands require a sessionId — pass the handle returned by attachToTarget.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						method: {
+							type: "string",
+							description: "CDP method, e.g. \"Target.createTarget\""
+						},
+						params: {
+							type: "object",
+							description: "CDP command parameters"
+						},
+						sessionId: {
+							type: "string",
+							description: "Session handle from attachToTarget, for page-scoped commands"
+						},
+						timeoutMs: {
+							type: "number",
+							description: "Per-command timeout override in milliseconds"
+						}
+					},
+					required: ["method"]
+				},
+				execute: async (args, ctx) => {
+					const { method, params, sessionId, timeoutMs } = args;
+					const executionId = _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx);
+					const socket = await _assertClassBrand(_BrowserConnector_brand, this, _socket).call(this, executionId);
+					const resolved = await _assertClassBrand(_BrowserConnector_brand, this, _resolveSessionHandle).call(this, executionId, sessionId);
+					try {
+						return await socket.send(method, params, {
+							sessionId: resolved,
+							timeoutMs
+						});
+					} catch (err) {
+						if (err instanceof Error && /-32601|wasn't found/.test(err.message)) {
+							if (await _assertClassBrand(_BrowserConnector_brand, this, _isSpecEvent).call(this, method)) throw new Error(`${err.message}. '${method}' is a CDP *event*, not a command — it cannot be called via cdp.send. To wait for page state, poll instead (e.g. Runtime.evaluate of document.readyState until "complete").`);
+							if (!sessionId) throw new Error(`${err.message}. Page-scoped commands need a sessionId: const { sessionId } = await cdp.attachToTarget({ targetId }); then pass sessionId to cdp.send.`);
+						}
+						throw err;
+					}
+				}
+			},
+			attachToTarget: {
+				description: "Attach to a target (tab) and return { sessionId } — a stable session handle to pass as sessionId in page-scoped send calls. The handle stays valid across pauses/resumes.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						targetId: {
+							type: "string",
+							description: "Target id from Target.createTarget/getTargets"
+						},
+						timeoutMs: { type: "number" }
+					},
+					required: ["targetId"]
+				},
+				outputSchema: {
+					type: "object",
+					properties: { sessionId: {
+						type: "string",
+						description: "Stable session handle for page-scoped send calls (valid across pauses/resumes)"
+					} },
+					required: ["sessionId"]
+				},
+				execute: async (args, ctx) => {
+					const { targetId, timeoutMs } = args;
+					const executionId = _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx);
+					await _assertClassBrand(_BrowserConnector_brand, this, _attach).call(this, executionId, targetId, timeoutMs);
+					return { sessionId: `${ATTACH_HANDLE_PREFIX}${targetId}` };
+				}
+			},
+			spec: {
+				description: "Return the searchable Chrome DevTools Protocol spec: domains with their commands, events, and types. Use it to discover method names and capabilities.",
+				replay: "reexecute",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async () => loadCdpSpec(_classPrivateFieldGet2(_options, this))
+			},
+			getDebugLog: {
+				description: "Return recent CDP protocol traffic (sends, receives, warnings) for this execution's connection — useful to diagnose failures and timeouts.",
+				replay: "reexecute",
+				inputSchema: {
+					type: "object",
+					properties: { limit: {
+						type: "number",
+						description: "Max entries to return (default 50)"
+					} }
+				},
+				execute: async (args, ctx) => {
+					const { limit } = args ?? {};
+					return (await _assertClassBrand(_BrowserConnector_brand, this, _socket).call(this, _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx))).getDebugLog(limit);
+				}
+			},
+			clearDebugLog: {
+				description: "Clear the CDP debug log for this execution's connection.",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async (_args, ctx) => {
+					(await _assertClassBrand(_BrowserConnector_brand, this, _socket).call(this, _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx))).clearDebugLog();
+					return null;
+				}
+			}
+		};
+		const mode = _assertClassBrand(_BrowserConnector_brand, this, _mode).call(this);
+		if (mode === "reuse" || mode === "dynamic") {
+			tools.startSession = {
+				description: mode === "dynamic" ? "Promote the current browser session into the shared slot so it persists after this execution. Later executions reuse it. Returns the session info." : "Ensure the shared browser session exists and return its info.",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async (_args, ctx) => _assertClassBrand(_BrowserConnector_brand, this, _startSession).call(this, _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx))
+			};
+			tools.sessionInfo = {
+				description: "Return info about the shared browser session (id and open targets), or null when none exists.",
+				replay: "reexecute",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async () => await this.sessionInfo() ?? null
+			};
+			tools.closeSession = {
+				description: "Close the shared browser session, discarding its tabs and state.",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async (_args, ctx) => {
+					await _assertClassBrand(_BrowserConnector_brand, this, _closeReusableFor).call(this, _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx));
+					return null;
+				}
+			};
+			tools.resetSession = {
+				description: "Close the shared browser session and start a fresh one. Returns the new session info.",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async (_args, ctx) => _assertClassBrand(_BrowserConnector_brand, this, _resetSession).call(this, _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx))
+			};
+		}
+		return tools;
+	}
+	/**
+	* A pass is over (completed, errored, or paused awaiting approval) — drop
+	* the CDP socket. The Browser Run session itself stays alive; a resume
+	* reconnects from the durably stored session id.
+	*/
+	async onPassEnd(executionId, _status) {
+		_assertClassBrand(_BrowserConnector_brand, this, _dropSocket).call(this, executionId);
+	}
+	/**
+	* The execution is terminal — delete its Browser Run session unless it was
+	* promoted to the shared slot via `cdp.startSession()`.
+	*/
+	async disposeExecution(executionId, _status) {
+		_assertClassBrand(_BrowserConnector_brand, this, _dropSocket).call(this, executionId);
+		if (!_classPrivateFieldGet2(_options, this).browser) return;
+		const store = _classPrivateFieldGet2(_options, this).store;
+		const execKey = _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId);
+		const lock = await store.acquireLock(execKey);
+		let toClose;
+		try {
+			const stored = await store.get(execKey);
+			if (!stored) return;
+			let promoted = false;
+			if (_assertClassBrand(_BrowserConnector_brand, this, _mode).call(this) === "dynamic") promoted = (await store.get(_assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this)))?.sessionId === stored.sessionId;
+			if (!promoted && stored.closedAt === void 0) toClose = stored;
+			await store.delete(execKey);
+		} finally {
+			await lock.release();
+		}
+		if (toClose) try {
+			await deleteBrowserSession(_classPrivateFieldGet2(_options, this).browser, toClose.sessionId);
+		} catch (error) {
+			console.warn(`[agents/browser] Failed to delete Browser Run session ${toClose.sessionId} for execution ${executionId}`, error);
+		}
+	}
+	/** Info about the shared (reuse/promoted) session, if one exists. */
+	async sessionInfo() {
+		if (!_classPrivateFieldGet2(_options, this).browser) return void 0;
+		const store = _classPrivateFieldGet2(_options, this).store;
+		const key = _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this);
+		const lock = await store.acquireLock(key);
+		let stored;
+		try {
+			stored = await store.get(key);
+		} finally {
+			await lock.release();
+		}
+		if (!stored) return void 0;
+		try {
+			return {
+				sessionId: stored.sessionId,
+				targets: await listBrowserTargets(_classPrivateFieldGet2(_options, this).browser, stored.sessionId)
+			};
+		} catch (error) {
+			if (isMissingBrowserSession(error)) {
+				await _assertClassBrand(_BrowserConnector_brand, this, _deleteStoredEntry).call(this, key, stored.sessionId);
+				return;
+			}
+			throw error;
+		}
+	}
+	/** Close the shared (reuse/promoted) session, if one exists. */
+	async closeSession() {
+		if (!_classPrivateFieldGet2(_options, this).browser) return;
+		await _assertClassBrand(_BrowserConnector_brand, this, _closeStoredSession).call(this, _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this));
+	}
+	/**
+	* Close stored sessions (shared and per-execution) idle past the threshold.
+	* Per-execution entries normally die with `disposeExecution` (or the
+	* codemode runtime's `expirePaused`); the sweep is the backstop for crashed
+	* hosts. Call it from a recurring alarm/scheduled task.
+	*
+	* Active executions bump their entry's `updatedAt` on use, so only runs
+	* idle past `maxExecIdleMs` (default 24h) are reclaimed. A swept
+	* per-execution entry is kept as a tombstone (`closedAt`) rather than
+	* deleted, so a later resume fails with a clear "session expired" error
+	* instead of silently continuing in a fresh browser; tombstones are
+	* deleted once they age past the threshold again.
+	*/
+	async sweep(options) {
+		if (!_classPrivateFieldGet2(_options, this).browser) return { swept: [] };
+		const store = _classPrivateFieldGet2(_options, this).store;
+		const maxIdleMs = options?.maxIdleMs ?? _classPrivateFieldGet2(_options, this).session?.keepAliveMs ?? 6e5;
+		const maxExecIdleMs = options?.maxExecIdleMs ?? 864e5;
+		const keys = new Set([_assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this)]);
+		if (store.list) for (const key of (await store.list("cdp:")).keys()) keys.add(key);
+		const swept = [];
+		for (const key of keys) {
+			const isExec = key.startsWith(EXEC_KEY_PREFIX);
+			const idleMs = isExec ? maxExecIdleMs : maxIdleMs;
+			const lock = await store.acquireLock(key);
+			let toClose;
+			try {
+				const stored = await store.get(key);
+				if (!stored) continue;
+				const now = Date.now();
+				if (stored.closedAt !== void 0) {
+					if (now - stored.closedAt >= idleMs) await store.delete(key);
+					continue;
+				}
+				if (now - stored.updatedAt < idleMs) continue;
+				if (isExec) await store.set(key, {
+					...stored,
+					closedAt: now
+				});
+				else await store.delete(key);
+				toClose = stored;
+			} finally {
+				await lock.release();
+			}
+			try {
+				await deleteBrowserSession(_classPrivateFieldGet2(_options, this).browser, toClose.sessionId);
+			} catch (error) {
+				console.warn(`[agents/browser] Sweep failed to delete Browser Run session ${toClose.sessionId}`, error);
+			}
+			swept.push({
+				key,
+				sessionId: toClose.sessionId
+			});
+		}
+		return { swept };
+	}
+};
+function _mode() {
+	return _classPrivateFieldGet2(_options, this).session?.mode ?? "one-shot";
+}
+function _execKey(executionId) {
+	return `${EXEC_KEY_PREFIX}${executionId}`;
+}
+function _reuseKey() {
+	return `${REUSE_KEY_PREFIX}${_classPrivateFieldGet2(_options, this).session?.key ?? "default"}`;
+}
+function _executionId(ctx) {
+	if (!ctx?.executionId) throw new Error("BrowserConnector requires an execution context — use it through createCodemodeRuntime");
+	return ctx.executionId;
+}
+function _dropSocket(executionId) {
+	const cached = _classPrivateFieldGet2(_sockets, this).get(executionId);
+	if (!cached) return;
+	_classPrivateFieldGet2(_sockets, this).delete(executionId);
+	cached.session.disconnect();
+}
+/** Attach the current socket to a target, caching the live CDP session id. */
+async function _attach(executionId, targetId, timeoutMs) {
+	const socket = await _assertClassBrand(_BrowserConnector_brand, this, _socket).call(this, executionId);
+	const cached = _classPrivateFieldGet2(_sockets, this).get(executionId);
+	const handle = `${ATTACH_HANDLE_PREFIX}${targetId}`;
+	const existing = cached?.attached.get(handle);
+	if (existing) return existing;
+	const live = await socket.attachToTarget(targetId, { timeoutMs });
+	cached?.attached.set(handle, live);
+	return live;
+}
+/**
+* Resolve a model-facing session handle to the live CDP session id on the
+* current socket, re-attaching lazily after a reconnect. Raw CDP session
+* ids (from manual Target.attachToTarget sends) pass through untouched.
+*/
+/**
+* True when `method` is a CDP *event* (e.g. `Page.loadEventFired`) rather
+* than a command. Used only on the `send` failure path to produce a better
+* error; any spec-loading failure just means no extra hint.
+*/
+async function _isSpecEvent(method) {
+	try {
+		const spec = await loadCdpSpec(_classPrivateFieldGet2(_options, this));
+		const domain = method.split(".")[0];
+		return spec.domains.some((d) => d.name === domain && d.events.some((e) => e.event === method));
+	} catch {
+		return false;
+	}
+}
+async function _resolveSessionHandle(executionId, sessionId) {
+	if (!sessionId?.startsWith(ATTACH_HANDLE_PREFIX)) return sessionId;
+	const targetId = sessionId.slice(7);
+	return _assertClassBrand(_BrowserConnector_brand, this, _attach).call(this, executionId, targetId);
+}
+/**
+* Get or open the CDP socket for an execution. Concurrent calls for the
+* same execution (model code that ignores the "sequential calls" rule and
+* uses Promise.all) share one in-flight connect instead of racing and
+* leaking the loser's WebSocket.
+*/
+function _socket(executionId) {
+	const inFlight = _classPrivateFieldGet2(_connecting, this).get(executionId);
+	if (inFlight) return inFlight;
+	const promise = _assertClassBrand(_BrowserConnector_brand, this, _socketInner).call(this, executionId).finally(() => {
+		if (_classPrivateFieldGet2(_connecting, this).get(executionId) === promise) _classPrivateFieldGet2(_connecting, this).delete(executionId);
+	});
+	_classPrivateFieldGet2(_connecting, this).set(executionId, promise);
+	return promise;
+}
+async function _socketInner(executionId) {
+	if (_classPrivateFieldGet2(_options, this).cdpUrl) {
+		const cached = _classPrivateFieldGet2(_sockets, this).get(executionId);
+		if (cached) return cached.session;
+		const session = await connectUrl(_classPrivateFieldGet2(_options, this).cdpUrl, {
+			timeoutMs: _classPrivateFieldGet2(_options, this).timeout,
+			headers: _classPrivateFieldGet2(_options, this).cdpHeaders
+		});
+		_classPrivateFieldGet2(_sockets, this).set(executionId, {
+			session,
+			attached: /* @__PURE__ */ new Map()
+		});
+		return session;
+	}
+	const browser = _classPrivateFieldGet2(_options, this).browser;
+	if (!browser) throw new Error("BrowserConnector has no browser binding");
+	const stored = await _assertClassBrand(_BrowserConnector_brand, this, _resolveSession).call(this, executionId);
+	const cached = _classPrivateFieldGet2(_sockets, this).get(executionId);
+	if (cached?.browserSessionId === stored.sessionId) return cached.session;
+	if (cached) _assertClassBrand(_BrowserConnector_brand, this, _dropSocket).call(this, executionId);
+	const session = await connectBrowserSession(browser, stored.sessionId, _classPrivateFieldGet2(_options, this).timeout);
+	_classPrivateFieldGet2(_sockets, this).set(executionId, {
+		session,
+		browserSessionId: stored.sessionId,
+		attached: /* @__PURE__ */ new Map()
+	});
+	return session;
+}
+/**
+* Resolve the Browser Run session for an execution:
+*
+* - An existing `cdp:exec:<id>` entry wins. If its session is gone (e.g.
+*   expired while the run was paused), the run fails with a clear error
+*   rather than silently continuing in a fresh browser.
+* - In `reuse` mode the shared session is used (created if missing).
+* - In `dynamic` mode an alive shared session is used; otherwise a fresh
+*   per-execution session is created.
+* - In `one-shot` mode a fresh per-execution session is created.
+*/
+async function _resolveSession(executionId) {
+	if (!_classPrivateFieldGet2(_options, this).browser) throw new Error("BrowserConnector has no browser binding");
+	const mode = _assertClassBrand(_BrowserConnector_brand, this, _mode).call(this);
+	const execKey = _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId);
+	if (mode === "reuse") return _assertClassBrand(_BrowserConnector_brand, this, _ensureStoredSession).call(this, _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this));
+	const existing = await _assertClassBrand(_BrowserConnector_brand, this, _readStored).call(this, execKey);
+	if (existing) {
+		if (existing.closedAt === void 0 && await _assertClassBrand(_BrowserConnector_brand, this, _isAlive).call(this, existing)) {
+			if (Date.now() - existing.updatedAt >= EXEC_TOUCH_INTERVAL_MS) await _assertClassBrand(_BrowserConnector_brand, this, _touchStored).call(this, execKey, existing);
+			return existing;
+		}
+		await _assertClassBrand(_BrowserConnector_brand, this, _deleteStoredEntry).call(this, execKey, existing.sessionId);
+		throw new Error(`Browser session ${existing.sessionId} expired or was swept while this execution was paused — the run cannot continue. Start a new execution.`);
+	}
+	if (mode === "dynamic") {
+		const shared = await _assertClassBrand(_BrowserConnector_brand, this, _readStored).call(this, _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this));
+		if (shared) {
+			if (await _assertClassBrand(_BrowserConnector_brand, this, _isAlive).call(this, shared)) {
+				await _assertClassBrand(_BrowserConnector_brand, this, _touchStored).call(this, _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this), shared);
+				return shared;
+			}
+			await _assertClassBrand(_BrowserConnector_brand, this, _deleteStoredEntry).call(this, _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this), shared.sessionId);
+		}
+	}
+	return _assertClassBrand(_BrowserConnector_brand, this, _createAndCommit).call(this, execKey);
+}
+/**
+* Get the stored session under `key`, validating and creating as needed.
+*
+* Network calls (the liveness probe, session creation) happen OUTSIDE the
+* store lock — locks wrap storage only, so a hung Browser Rendering call
+* can't serialize every other operation on this key. The lock is
+* re-acquired to commit, with a sessionId re-check to detect a concurrent
+* swap; on a swap the new entry is re-validated from the top.
+*/
+async function _ensureStoredSession(key) {
+	if (!_classPrivateFieldGet2(_options, this).browser) throw new Error("BrowserConnector has no browser binding");
+	const store = _get_store.call(_assertClassBrand(_BrowserConnector_brand, this));
+	for (let attempt = 0; attempt < 3; attempt++) {
+		const existing = await store.get(key);
+		if (!existing) return _assertClassBrand(_BrowserConnector_brand, this, _createAndCommit).call(this, key);
+		const alive = await _assertClassBrand(_BrowserConnector_brand, this, _isAlive).call(this, existing);
+		const lock = await store.acquireLock(key);
+		try {
+			const current = await store.get(key);
+			if (current?.sessionId !== existing.sessionId) continue;
+			if (alive) {
+				const refreshed = {
+					...current,
+					updatedAt: Date.now()
+				};
+				await store.set(key, refreshed);
+				return refreshed;
+			}
+			await store.delete(key);
+		} finally {
+			await lock.release();
+		}
+	}
+	throw new Error(`Browser session entry ${key} kept changing concurrently — retry`);
+}
+/**
+* Create a Browser Run session (outside any lock) and commit it under
+* `key`. If a concurrent caller committed first, their entry wins and the
+* redundant session is deleted best-effort.
+*/
+async function _createAndCommit(key) {
+	const browser = _classPrivateFieldGet2(_options, this).browser;
+	if (!browser) throw new Error("BrowserConnector has no browser binding");
+	const store = _get_store.call(_assertClassBrand(_BrowserConnector_brand, this));
+	const info = await createBrowserSession(browser, { keepAliveMs: _classPrivateFieldGet2(_options, this).session?.keepAliveMs });
+	const now = Date.now();
+	const stored = {
+		sessionId: info.sessionId,
+		createdAt: now,
+		updatedAt: now
+	};
+	const lock = await store.acquireLock(key);
+	let winner;
+	try {
+		const raced = await store.get(key);
+		if (raced) winner = raced;
+		else await store.set(key, stored);
+	} finally {
+		await lock.release();
+	}
+	if (winner) {
+		try {
+			await deleteBrowserSession(browser, stored.sessionId);
+		} catch (error) {
+			console.warn(`[agents/browser] Failed to delete redundant Browser Run session ${stored.sessionId}`, error);
+		}
+		return winner;
+	}
+	return stored;
+}
+async function _isAlive(stored) {
+	const browser = _classPrivateFieldGet2(_options, this).browser;
+	if (!browser) return false;
+	try {
+		await listBrowserTargets(browser, stored.sessionId);
+		return true;
+	} catch (error) {
+		if (isMissingBrowserSession(error)) return false;
+		throw error;
+	}
+}
+async function _startSession(executionId) {
+	const browser = _classPrivateFieldGet2(_options, this).browser;
+	if (!browser) throw new Error("startSession requires the Browser Rendering binding");
+	const store = _classPrivateFieldGet2(_options, this).store;
+	const reuseKey = _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this);
+	if (_assertClassBrand(_BrowserConnector_brand, this, _mode).call(this) === "dynamic") {
+		const exec = await _assertClassBrand(_BrowserConnector_brand, this, _readStored).call(this, _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId));
+		if (exec && exec.closedAt === void 0) {
+			const lock = await store.acquireLock(reuseKey);
+			let replaced;
+			try {
+				const shared = await store.get(reuseKey);
+				if (shared?.sessionId !== exec.sessionId) {
+					replaced = shared;
+					await store.set(reuseKey, {
+						...exec,
+						updatedAt: Date.now()
+					});
+				}
+			} finally {
+				await lock.release();
+			}
+			if (replaced) try {
+				await deleteBrowserSession(browser, replaced.sessionId);
+			} catch (error) {
+				console.warn(`[agents/browser] Failed to delete replaced Browser Run session ${replaced.sessionId}`, error);
+			}
+			return {
+				sessionId: exec.sessionId,
+				targets: await listBrowserTargets(browser, exec.sessionId)
+			};
+		}
+	}
+	const stored = await _assertClassBrand(_BrowserConnector_brand, this, _ensureStoredSession).call(this, reuseKey);
+	return {
+		sessionId: stored.sessionId,
+		targets: await listBrowserTargets(browser, stored.sessionId)
+	};
+}
+async function _resetSession(executionId) {
+	const browser = _classPrivateFieldGet2(_options, this).browser;
+	if (!browser) throw new Error("resetSession requires the Browser Rendering binding");
+	await _assertClassBrand(_BrowserConnector_brand, this, _closeReusableFor).call(this, executionId);
+	const stored = await _assertClassBrand(_BrowserConnector_brand, this, _ensureStoredSession).call(this, _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this));
+	return {
+		sessionId: stored.sessionId,
+		targets: await listBrowserTargets(browser, stored.sessionId)
+	};
+}
+/**
+* Close the shared session from inside an execution. If this execution's
+* socket is attached to that session, drop it first.
+*/
+async function _closeReusableFor(executionId) {
+	const reuseKey = _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this);
+	const stored = await _assertClassBrand(_BrowserConnector_brand, this, _readStored).call(this, reuseKey);
+	if (!stored) return;
+	if (_classPrivateFieldGet2(_sockets, this).get(executionId)?.browserSessionId === stored.sessionId) _assertClassBrand(_BrowserConnector_brand, this, _dropSocket).call(this, executionId);
+	await _assertClassBrand(_BrowserConnector_brand, this, _closeStoredSession).call(this, reuseKey);
+	const exec = await _assertClassBrand(_BrowserConnector_brand, this, _readStored).call(this, _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId));
+	if (exec?.sessionId === stored.sessionId) await _assertClassBrand(_BrowserConnector_brand, this, _deleteStoredEntry).call(this, _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId), exec.sessionId);
+}
+function _get_store() {
+	const store = _classPrivateFieldGet2(_options, this).store;
+	if (!store) throw new Error("BrowserConnector session storage requires the Browser Rendering binding");
+	return store;
+}
+async function _readStored(key) {
+	const store = _get_store.call(_assertClassBrand(_BrowserConnector_brand, this));
+	const lock = await store.acquireLock(key);
+	try {
+		return await store.get(key);
+	} finally {
+		await lock.release();
+	}
+}
+async function _writeStored(key, value) {
+	const store = _get_store.call(_assertClassBrand(_BrowserConnector_brand, this));
+	const lock = await store.acquireLock(key);
+	try {
+		await store.set(key, value);
+	} finally {
+		await lock.release();
+	}
+}
+async function _touchStored(key, value) {
+	await _assertClassBrand(_BrowserConnector_brand, this, _writeStored).call(this, key, {
+		...value,
+		updatedAt: Date.now()
+	});
+}
+/** Delete the store entry only if it still points at `sessionId`. */
+async function _deleteStoredEntry(key, sessionId) {
+	const store = _get_store.call(_assertClassBrand(_BrowserConnector_brand, this));
+	const lock = await store.acquireLock(key);
+	try {
+		if ((await store.get(key))?.sessionId === sessionId) await store.delete(key);
+	} finally {
+		await lock.release();
+	}
+}
+/** Delete the stored entry under `key` and its Browser Run session. */
+async function _closeStoredSession(key) {
+	const browser = _classPrivateFieldGet2(_options, this).browser;
+	if (!browser) return;
+	const store = _classPrivateFieldGet2(_options, this).store;
+	const lock = await store.acquireLock(key);
+	let stored;
+	try {
+		stored = await store.get(key);
+		if (stored) await store.delete(key);
+	} finally {
+		await lock.release();
+	}
+	if (stored) await deleteBrowserSession(browser, stored.sessionId);
+}
+//#endregion
+export { loadCdpSpec as a, connectBrowserSession as c, listBrowserTargets as d, CdpSession as f, DurableBrowserSessionStore as i, createBrowserSession as l, DEFAULT_EXEC_SWEEP_IDLE_MS as n, BrowserRenderingError as o, connectUrl as p, DEFAULT_SWEEP_IDLE_MS as r, connectBrowser as s, BrowserConnector as t, deleteBrowserSession as u };
+
+//# sourceMappingURL=connector-D6yYzYHg.js.map