rea-agents 6.5.0 → 6.7.0

package/dist/mcp/{CdpConnection-BpDfz4MK.js → CdpEndpoint-BrhMhpSi.js}

@@ -1,13 +1,359 @@
 import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
-import { f as init_analysisErrorCore, i as AnalysisCancelledError, m as init_analysisErrorBase, p as AnalysisError } from "./analysisErrorCore-DXRTvF_m.js";
+import { D as AnalysisError, O as init_analysisErrorBase, f as init_analysisErrorCore, i as AnalysisCancelledError } from "./analysisErrorCore-BIEP7tvF.js";
 import { n as safeParseJson, t as init_safeJson } from "./safeJson-NeGfpkrI.js";
-import { n as init_browserObservationError, t as BrowserObservationError } from "./browserObservationError-CyLugqX4.js";
-import { _ as init_urlComponents, c as init_browserObservation, m as sanitizeBrowserUrl, v as urlDeclaresQueryOrFragment } from "./webContentArtifact-Dzjc1z-R.js";
-import { n as init_webRuntime, t as WEB_RUNTIME_LIMITS } from "./webRuntime-K__NYzXm.js";
+import { n as init_browserObservationError, t as BrowserObservationError } from "./browserObservationError-C5okJ5el.js";
+import { _ as init_urlComponents, c as init_browserObservation, m as sanitizeBrowserUrl, v as urlDeclaresQueryOrFragment } from "./webContentArtifact-DfGkgDcI.js";
+import { n as init_webRuntime, t as WEB_RUNTIME_LIMITS } from "./webRuntime-ccyhkRru.js";
 import { z } from "zod";
-import { request } from "node:http";
 import WebSocket from "ws";
+import { request } from "node:http";
+
+//#region dist/browser/CdpCommandRejection.js
+var CdpCommandRejection;
+function init_CdpCommandRejection() {
+	return (init_CdpCommandRejection = __esmMin((() => {
+		init_browserObservationError();
+		CdpCommandRejection = class extends BrowserObservationError {
+			command;
+			code;
+			reportedMessage;
+			constructor(operation, command, code, reportedMessage) {
+				super(operation, "protocol_error", { detail: reportedMessage === null ? "CDP returned a malformed command error." : `CDP ${command} failed (${code === null ? "unknown code" : String(code)}): ${reportedMessage}` });
+				this.command = command;
+				this.code = code;
+				this.reportedMessage = reportedMessage;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpConnection.js
+var MAX_WEBSOCKET_PAYLOAD_BYTES, CdpConnection, socketIsClosed, rawText, isRecord, waitForOpen, terminateSocket;
+function init_CdpConnection() {
+	return (init_CdpConnection = __esmMin((() => {
+		init_analysisErrorCore();
+		init_analysisErrorBase();
+		init_browserObservationError();
+		init_CdpCommandRejection();
+		init_safeJson();
+		init_webRuntime();
+		MAX_WEBSOCKET_PAYLOAD_BYTES = 2147483647;
+		CdpConnection = class CdpConnection {
+			socket;
+			operation;
+			maxPayloadBytes;
+			#pending = new Map();
+			#listeners = new Set();
+			#disconnectListeners = new Set();
+			#protocolFailureListeners = new Set();
+			#nextId = 1;
+			#closed = false;
+			#closePromise;
+			#protocolFailed = false;
+			#transportFailure = "disconnected";
+			constructor(socket, operation, maxPayloadBytes) {
+				this.socket = socket;
+				this.operation = operation;
+				this.maxPayloadBytes = maxPayloadBytes;
+				socket.on("message", (data) => this.#receive(data));
+				socket.on("close", () => this.#disconnect());
+				socket.on("error", (cause) => this.#disconnect(isRecord(cause) && cause.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" ? "payload_limit" : "disconnected"));
+			}
+			/** Connect to one already-validated loopback CDP WebSocket. */
+			static async connect(url, operation, signal, limits, onConnected) {
+				if (signal?.aborted === true) throw new AnalysisCancelledError(operation);
+				const maxPayloadBytes = limits === undefined ? WEB_RUNTIME_LIMITS.protocolBytes : limits.maxPayloadBytes;
+				if (!Number.isSafeInteger(maxPayloadBytes) || maxPayloadBytes <= 0 || maxPayloadBytes > MAX_WEBSOCKET_PAYLOAD_BYTES) throw new RangeError(`CDP maxPayloadBytes must be a positive safe integer no greater than ${String(MAX_WEBSOCKET_PAYLOAD_BYTES)}.`);
+				const socket = new WebSocket(url, {
+					handshakeTimeout: 0,
+					maxPayload: maxPayloadBytes,
+					perMessageDeflate: false
+				});
+				const connection = new CdpConnection(socket, operation, maxPayloadBytes);
+				try {
+					onConnected?.(connection);
+				} catch (cause) {
+					await connection.close();
+					throw cause;
+				}
+				try {
+					await waitForOpen(socket, operation, signal);
+				} catch (cause) {
+					if (onConnected === undefined) {
+						try {
+							await connection.close();
+						} catch (cleanupCause) {
+							throw new AggregateError([cause, cleanupCause], "CDP WebSocket handshake failed and its transport cleanup is incomplete.", { cause });
+						}
+					}
+					throw cause;
+				}
+				return connection;
+			}
+			/** Subscribe to validated CDP event envelopes. */
+			onEvent(listener) {
+				this.#listeners.add(listener);
+				return () => this.#listeners.delete(listener);
+			}
+			/** Subscribe to an unexpected transport loss while an operation is active. */
+			onDisconnect(listener) {
+				if (this.#closed) {
+					listener(this.#transportError(this.#transportFailure));
+					return () => undefined;
+				}
+				this.#disconnectListeners.add(listener);
+				return () => this.#disconnectListeners.delete(listener);
+			}
+			/** Notify fatal wire parsing failure even when no command is outstanding. */
+			onProtocolFailure(listener) {
+				if (this.#protocolFailed) {
+					listener(this.#transportError("protocol_error"));
+					return () => undefined;
+				}
+				this.#protocolFailureListeners.add(listener);
+				return () => this.#protocolFailureListeners.delete(listener);
+			}
+			/** Bound each response separately from the caller-selected observation window. */
+			async send(method, params = {}, sessionId, signal) {
+				if (this.#protocolFailed) throw new BrowserObservationError(this.operation, "protocol_error");
+				if (this.#closed || this.socket.readyState !== WebSocket.OPEN) throw this.#transportError(this.#transportFailure);
+				if (signal?.aborted === true) throw new AnalysisCancelledError(this.operation);
+				const id = this.#nextId;
+				this.#nextId += 1;
+				const message = JSON.stringify({
+					id,
+					method,
+					params,
+					...sessionId === undefined ? {} : { sessionId }
+				});
+				return await new Promise((resolve, reject) => {
+					const onAbort = () => {
+						const pending = this.#pending.get(id);
+						if (pending === undefined) return;
+						this.#complete(id, pending);
+						reject(new AnalysisCancelledError(this.operation));
+					};
+					const timer = setTimeout(() => {
+						const pending = this.#pending.get(id);
+						if (pending === undefined) return;
+						this.#complete(id, pending);
+						reject(new BrowserObservationError(this.operation, "timeout", { detail: `CDP command ${method} exceeded its ${String(WEB_RUNTIME_LIMITS.commandTimeoutMs)} ms response deadline.` }));
+					}, WEB_RUNTIME_LIMITS.commandTimeoutMs);
+					signal?.addEventListener("abort", onAbort, { once: true });
+					this.#pending.set(id, {
+						method,
+						...sessionId === undefined ? {} : { sessionId },
+						resolve,
+						reject,
+						dispose: () => {
+							clearTimeout(timer);
+							signal?.removeEventListener("abort", onAbort);
+						}
+					});
+					this.socket.send(message, (error) => {
+						if (error === undefined || error === null) return;
+						const pending = this.#pending.get(id);
+						if (pending === undefined) return;
+						this.#complete(id, pending);
+						reject(new BrowserObservationError(this.operation, "disconnected", { cause: error }));
+					});
+				});
+			}
+			/** Close only REA's socket; never close the browser or selected page. */
+			close() {
+				this.#closePromise ??= this.#closeTransport().catch((cause) => {
+					this.#closePromise = undefined;
+					throw cause;
+				});
+				return this.#closePromise;
+			}
+			async #closeTransport() {
+				this.#closed = true;
+				this.#failPending("disconnected");
+				if (socketIsClosed(this.socket)) return;
+				await new Promise((resolve, reject) => {
+					let settled = false;
+					let fallbackStarted = false;
+					let fallbackTimer;
+					const finish = (cause) => {
+						if (settled) return;
+						settled = true;
+						clearTimeout(timer);
+						if (fallbackTimer !== undefined) clearTimeout(fallbackTimer);
+						this.socket.off("close", onClose);
+						if (cause === undefined) resolve();
+						else reject(cause);
+					};
+					const onClose = () => finish();
+					const forceClose = (gracefulFailure) => {
+						if (settled || fallbackStarted) return;
+						fallbackStarted = true;
+						clearTimeout(timer);
+						if (socketIsClosed(this.socket)) {
+							finish();
+							return;
+						}
+						try {
+							this.socket.terminate();
+						} catch (cause) {
+							gracefulFailure = gracefulFailure === undefined ? cause : new AggregateError([gracefulFailure, cause], "Graceful and forced CDP WebSocket close both failed.", { cause: gracefulFailure });
+						}
+						if (socketIsClosed(this.socket)) finish();
+						else {
+							fallbackTimer = setTimeout(() => {
+								if (socketIsClosed(this.socket)) {
+									finish();
+									return;
+								}
+								finish(gracefulFailure ?? new BrowserObservationError(this.operation, "cleanup_failed", { detail: "REA could not confirm release of its CDP WebSocket." }));
+							}, 1e3);
+						}
+					};
+					const timer = setTimeout(() => forceClose(), 1e3);
+					this.socket.once("close", onClose);
+					try {
+						this.socket.close();
+					} catch (closeCause) {
+						forceClose(closeCause);
+					}
+				});
+			}
+			#receive(data) {
+				if (this.#closed || this.#protocolFailed) return;
+				const parsed = safeParseJson(rawText(data));
+				if (!parsed.ok) {
+					this.#failPending("protocol_error");
+					return;
+				}
+				const message = parsed.value;
+				if (!isRecord(message)) {
+					this.#failPending("protocol_error");
+					return;
+				}
+				if ("id" in message) {
+					if (typeof message.id !== "number" || !Number.isSafeInteger(message.id) || message.id < 1) {
+						this.#failPending("protocol_error");
+						return;
+					}
+					this.#receiveResponse(message, message.id);
+					return;
+				}
+				if (typeof message.method !== "string" || message.method.length === 0 || "params" in message && !isRecord(message.params) || "sessionId" in message && typeof message.sessionId !== "string") {
+					this.#failPending("protocol_error");
+					return;
+				}
+				const event = {
+					method: message.method,
+					params: "params" in message ? message.params : {},
+					...typeof message.sessionId === "string" ? { sessionId: message.sessionId } : {}
+				};
+				for (const listener of this.#listeners) listener(event);
+			}
+			#receiveResponse(message, id) {
+				const pending = this.#pending.get(id);
+				if (pending === undefined) return;
+				const hasResult = "result" in message;
+				const hasError = "error" in message;
+				const detachedSessionError = pending.sessionId !== undefined && !("sessionId" in message) && hasError && isRecord(message.error) && message.error.code === -32001 && message.error.message === "Session with given id not found.";
+				if ((pending.sessionId === undefined ? "sessionId" in message : message.sessionId !== pending.sessionId && !detachedSessionError) || hasResult === hasError) {
+					this.#failPending("protocol_error");
+					return;
+				}
+				if (hasResult) {
+					if (!isRecord(message.result)) {
+						this.#failPending("protocol_error");
+						return;
+					}
+					this.#complete(id, pending);
+					pending.resolve(message.result);
+					return;
+				}
+				const reported = message.error;
+				if (!isRecord(reported) || typeof reported.code !== "number" || !Number.isSafeInteger(reported.code) || typeof reported.message !== "string") {
+					this.#failPending("protocol_error");
+					return;
+				}
+				this.#complete(id, pending);
+				pending.reject(new CdpCommandRejection(this.operation, pending.method, reported.code, reported.message));
+			}
+			#complete(id, pending) {
+				pending.dispose();
+				this.#pending.delete(id);
+			}
+			#failPending(reason) {
+				const wasProtocolFailed = this.#protocolFailed;
+				if (reason !== "protocol_error") this.#closed = true;
+				else this.#protocolFailed = true;
+				for (const [id, pending] of this.#pending) {
+					this.#complete(id, pending);
+					pending.reject(this.#transportError(reason));
+				}
+				if (reason === "protocol_error" && !wasProtocolFailed) {
+					const error = this.#transportError(reason);
+					for (const listener of this.#protocolFailureListeners) listener(error);
+					this.#protocolFailureListeners.clear();
+				}
+			}
+			#disconnect(reason = "disconnected") {
+				const wasClosed = this.#closed;
+				if (!wasClosed) this.#transportFailure = reason;
+				this.#failPending(reason);
+				if (wasClosed) return;
+				const error = this.#transportError(reason);
+				for (const listener of this.#disconnectListeners) listener(error);
+				this.#disconnectListeners.clear();
+			}
+			#transportError(reason) {
+				return new BrowserObservationError(this.operation, reason, reason === "payload_limit" ? { detail: `CDP message exceeded the selected ${String(this.maxPayloadBytes)} byte protocol budget.` } : undefined);
+			}
+		};
+		socketIsClosed = (socket) => socket.readyState === WebSocket.CLOSED;
+		rawText = (data) => Array.isArray(data) ? Buffer.concat(data).toString("utf8") : Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.from(data).toString("utf8");
+		isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+		waitForOpen = async (socket, operation, signal) => await new Promise((resolve, reject) => {
+			const onOpen = () => {
+				cleanup();
+				resolve();
+			};
+			const onFailure = (cause) => {
+				cleanup();
+				reject(signal?.aborted === true ? new AnalysisCancelledError(operation) : new BrowserObservationError(operation, "endpoint_unreachable", { cause }));
+			};
+			const onClose = (code, reason) => {
+				onFailure(new Error(`CDP WebSocket closed before opening (${code}: ${reason.toString("utf8")})`));
+			};
+			const onAbort = () => {
+				terminateSocket(socket);
+				onFailure(new AnalysisCancelledError(operation));
+			};
+			const cleanup = () => {
+				clearTimeout(timer);
+				socket.off("open", onOpen);
+				socket.off("error", onFailure);
+				socket.off("close", onClose);
+				signal?.removeEventListener("abort", onAbort);
+			};
+			const timer = setTimeout(() => {
+				terminateSocket(socket);
+				cleanup();
+				reject(new BrowserObservationError(operation, "timeout", { detail: `CDP WebSocket handshake exceeded its ${String(WEB_RUNTIME_LIMITS.commandTimeoutMs)} ms deadline.` }));
+			}, WEB_RUNTIME_LIMITS.commandTimeoutMs);
+			socket.once("open", onOpen);
+			socket.once("error", onFailure);
+			socket.once("close", onClose);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			if (signal?.aborted === true) onAbort();
+		});
+		terminateSocket = (socket) => {
+			try {
+				socket.terminate();
+			} catch {}
+		};
+	})))();
+}
 
+//#endregion
 //#region dist/browser/CdpEndpoint.js
 var endpointVersionSchema, endpointTargetSchema, endpointTargetsSchema, CDP_DISCOVERY_RESPONSE_LIMITS, browserSocketVersionSchema, browserSocketTargetsSchema, discoverCdpEndpoint, withCdpDiscoveryDeadline, discoverCdpBrowserSocket, sanitizeTargetTitle, sanitizeTargetUrlAlias, sanitizeSameOriginTitleUrl, escapeRegExp, cdpTargetWebSocket, hasCdpTargetWebSocket, availableCdpTargetWebSocket, parseCdpEndpointValue, safeCdpWebSocketEndpoint, cdpWebSocketPath, pathIdentifier, targetWebSocket, readCdpJson, endpointFailure;
 function init_CdpEndpoint() {
@@ -292,279 +638,4 @@ function init_CdpEndpoint() {
 }
 
 //#endregion
-//#region dist/browser/CdpCommandRejection.js
-var CdpCommandRejection;
-function init_CdpCommandRejection() {
-	return (init_CdpCommandRejection = __esmMin((() => {
-		init_browserObservationError();
-		CdpCommandRejection = class extends BrowserObservationError {
-			command;
-			code;
-			reportedMessage;
-			constructor(operation, command, code, reportedMessage) {
-				super(operation, "protocol_error", { detail: reportedMessage === null ? "CDP returned a malformed command error." : `CDP ${command} failed (${code === null ? "unknown code" : String(code)}): ${reportedMessage}` });
-				this.command = command;
-				this.code = code;
-				this.reportedMessage = reportedMessage;
-			}
-		};
-	})))();
-}
-
-//#endregion
-//#region dist/browser/CdpConnection.js
-var MAX_WEBSOCKET_PAYLOAD_BYTES, CdpConnection, rawText, isRecord, waitForOpen, terminateSocket;
-function init_CdpConnection() {
-	return (init_CdpConnection = __esmMin((() => {
-		init_analysisErrorCore();
-		init_analysisErrorBase();
-		init_browserObservationError();
-		init_CdpCommandRejection();
-		init_safeJson();
-		init_webRuntime();
-		MAX_WEBSOCKET_PAYLOAD_BYTES = 2147483647;
-		CdpConnection = class CdpConnection {
-			socket;
-			operation;
-			maxPayloadBytes;
-			#pending = new Map();
-			#listeners = new Set();
-			#disconnectListeners = new Set();
-			#protocolFailureListeners = new Set();
-			#nextId = 1;
-			#closed = false;
-			#closePromise;
-			#protocolFailed = false;
-			#transportFailure = "disconnected";
-			constructor(socket, operation, maxPayloadBytes) {
-				this.socket = socket;
-				this.operation = operation;
-				this.maxPayloadBytes = maxPayloadBytes;
-				socket.on("message", (data) => this.#receive(data));
-				socket.on("close", () => this.#disconnect());
-				socket.on("error", (cause) => this.#disconnect(isRecord(cause) && cause.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" ? "payload_limit" : "disconnected"));
-			}
-			/** Connect to one already-validated loopback CDP WebSocket. */
-			static async connect(url, operation, signal, limits) {
-				if (signal?.aborted === true) throw new AnalysisCancelledError(operation);
-				const maxPayloadBytes = limits === undefined ? WEB_RUNTIME_LIMITS.protocolBytes : limits.maxPayloadBytes;
-				if (!Number.isSafeInteger(maxPayloadBytes) || maxPayloadBytes <= 0 || maxPayloadBytes > MAX_WEBSOCKET_PAYLOAD_BYTES) throw new RangeError(`CDP maxPayloadBytes must be a positive safe integer no greater than ${String(MAX_WEBSOCKET_PAYLOAD_BYTES)}.`);
-				const socket = new WebSocket(url, {
-					handshakeTimeout: 0,
-					maxPayload: maxPayloadBytes,
-					perMessageDeflate: false
-				});
-				await waitForOpen(socket, operation, signal);
-				return new CdpConnection(socket, operation, maxPayloadBytes);
-			}
-			/** Subscribe to validated CDP event envelopes. */
-			onEvent(listener) {
-				this.#listeners.add(listener);
-				return () => this.#listeners.delete(listener);
-			}
-			/** Subscribe to an unexpected transport loss while an operation is active. */
-			onDisconnect(listener) {
-				if (this.#closed) {
-					listener(this.#transportError(this.#transportFailure));
-					return () => undefined;
-				}
-				this.#disconnectListeners.add(listener);
-				return () => this.#disconnectListeners.delete(listener);
-			}
-			/** Notify fatal wire parsing failure even when no command is outstanding. */
-			onProtocolFailure(listener) {
-				if (this.#protocolFailed) {
-					listener(this.#transportError("protocol_error"));
-					return () => undefined;
-				}
-				this.#protocolFailureListeners.add(listener);
-				return () => this.#protocolFailureListeners.delete(listener);
-			}
-			/** Execute one command, optionally within a flat target session. */
-			async send(method, params = {}, sessionId, signal) {
-				if (this.#protocolFailed) throw new BrowserObservationError(this.operation, "protocol_error");
-				if (this.#closed || this.socket.readyState !== WebSocket.OPEN) throw this.#transportError(this.#transportFailure);
-				if (signal?.aborted === true) throw new AnalysisCancelledError(this.operation);
-				const id = this.#nextId;
-				this.#nextId += 1;
-				return await new Promise((resolve, reject) => {
-					const onAbort = () => {
-						const pending = this.#pending.get(id);
-						if (pending === undefined) return;
-						pending.removeAbort();
-						this.#pending.delete(id);
-						reject(new AnalysisCancelledError(this.operation));
-					};
-					signal?.addEventListener("abort", onAbort, { once: true });
-					this.#pending.set(id, {
-						method,
-						...sessionId === undefined ? {} : { sessionId },
-						resolve,
-						reject,
-						removeAbort: () => signal?.removeEventListener("abort", onAbort)
-					});
-					this.socket.send(JSON.stringify({
-						id,
-						method,
-						params,
-						...sessionId === undefined ? {} : { sessionId }
-					}), (error) => {
-						if (error === undefined || error === null) return;
-						const pending = this.#pending.get(id);
-						if (pending === undefined) return;
-						this.#complete(id, pending);
-						reject(new BrowserObservationError(this.operation, "disconnected", { cause: error }));
-					});
-				});
-			}
-			/** Close only REA's socket; never close the browser or selected page. */
-			close() {
-				this.#closePromise ??= this.#closeTransport().catch((cause) => {
-					this.#closePromise = undefined;
-					throw cause;
-				});
-				return this.#closePromise;
-			}
-			async #closeTransport() {
-				this.#closed = true;
-				this.#failPending("disconnected");
-				if (this.socket.readyState === WebSocket.CLOSED) return;
-				await new Promise((resolve) => {
-					const timer = setTimeout(() => {
-						this.socket.terminate();
-						resolve();
-					}, 1e3);
-					this.socket.once("close", () => {
-						clearTimeout(timer);
-						resolve();
-					});
-					this.socket.close();
-				});
-			}
-			#receive(data) {
-				if (this.#closed || this.#protocolFailed) return;
-				const parsed = safeParseJson(rawText(data));
-				if (!parsed.ok) {
-					this.#failPending("protocol_error");
-					return;
-				}
-				const message = parsed.value;
-				if (!isRecord(message)) {
-					this.#failPending("protocol_error");
-					return;
-				}
-				if ("id" in message) {
-					if (typeof message.id !== "number" || !Number.isSafeInteger(message.id) || message.id < 1) {
-						this.#failPending("protocol_error");
-						return;
-					}
-					this.#receiveResponse(message, message.id);
-					return;
-				}
-				if (typeof message.method !== "string" || message.method.length === 0 || "params" in message && !isRecord(message.params) || "sessionId" in message && typeof message.sessionId !== "string") {
-					this.#failPending("protocol_error");
-					return;
-				}
-				const event = {
-					method: message.method,
-					params: "params" in message ? message.params : {},
-					...typeof message.sessionId === "string" ? { sessionId: message.sessionId } : {}
-				};
-				for (const listener of this.#listeners) listener(event);
-			}
-			#receiveResponse(message, id) {
-				const pending = this.#pending.get(id);
-				if (pending === undefined) return;
-				const hasResult = "result" in message;
-				const hasError = "error" in message;
-				if ((pending.sessionId === undefined ? "sessionId" in message : message.sessionId !== pending.sessionId) || hasResult === hasError) {
-					this.#failPending("protocol_error");
-					return;
-				}
-				if (hasResult) {
-					if (!isRecord(message.result)) {
-						this.#failPending("protocol_error");
-						return;
-					}
-					this.#complete(id, pending);
-					pending.resolve(message.result);
-					return;
-				}
-				const reported = message.error;
-				if (!isRecord(reported) || typeof reported.code !== "number" || !Number.isSafeInteger(reported.code) || typeof reported.message !== "string") {
-					this.#failPending("protocol_error");
-					return;
-				}
-				this.#complete(id, pending);
-				pending.reject(new CdpCommandRejection(this.operation, pending.method, reported.code, reported.message));
-			}
-			#complete(id, pending) {
-				pending.removeAbort();
-				this.#pending.delete(id);
-			}
-			#failPending(reason) {
-				const wasProtocolFailed = this.#protocolFailed;
-				if (reason !== "protocol_error") this.#closed = true;
-				else this.#protocolFailed = true;
-				for (const [id, pending] of this.#pending) {
-					this.#complete(id, pending);
-					pending.reject(this.#transportError(reason));
-				}
-				if (reason === "protocol_error" && !wasProtocolFailed) {
-					const error = this.#transportError(reason);
-					for (const listener of this.#protocolFailureListeners) listener(error);
-					this.#protocolFailureListeners.clear();
-				}
-			}
-			#disconnect(reason = "disconnected") {
-				const wasClosed = this.#closed;
-				if (!wasClosed) this.#transportFailure = reason;
-				this.#failPending(reason);
-				if (wasClosed) return;
-				const error = this.#transportError(reason);
-				for (const listener of this.#disconnectListeners) listener(error);
-				this.#disconnectListeners.clear();
-			}
-			#transportError(reason) {
-				return new BrowserObservationError(this.operation, reason, reason === "payload_limit" ? { detail: `CDP message exceeded the selected ${String(this.maxPayloadBytes)} byte protocol budget.` } : undefined);
-			}
-		};
-		rawText = (data) => Array.isArray(data) ? Buffer.concat(data).toString("utf8") : Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.from(data).toString("utf8");
-		isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-		waitForOpen = async (socket, operation, signal) => await new Promise((resolve, reject) => {
-			const onOpen = () => {
-				cleanup();
-				resolve();
-			};
-			const onFailure = (cause) => {
-				cleanup();
-				reject(signal?.aborted === true ? new AnalysisCancelledError(operation) : new BrowserObservationError(operation, "endpoint_unreachable", { cause }));
-			};
-			const onClose = (code, reason) => {
-				onFailure(new Error(`CDP WebSocket closed before opening (${code}: ${reason.toString("utf8")})`));
-			};
-			const onAbort = () => {
-				terminateSocket(socket);
-				onFailure(new AnalysisCancelledError(operation));
-			};
-			const cleanup = () => {
-				socket.off("open", onOpen);
-				socket.off("error", onFailure);
-				socket.off("close", onClose);
-				signal?.removeEventListener("abort", onAbort);
-			};
-			socket.once("open", onOpen);
-			socket.once("error", onFailure);
-			socket.once("close", onClose);
-			signal?.addEventListener("abort", onAbort, { once: true });
-			if (signal?.aborted === true) onAbort();
-		});
-		terminateSocket = (socket) => {
-			socket.once("error", () => undefined);
-			socket.terminate();
-		};
-	})))();
-}
-
-//#endregion
-export { cdpTargetWebSocket as a, hasCdpTargetWebSocket as c, readCdpJson as d, withCdpDiscoveryDeadline as f, init_CdpCommandRejection as i, init_CdpEndpoint as l, init_CdpConnection as n, discoverCdpBrowserSocket as o, CdpCommandRejection as r, discoverCdpEndpoint as s, CdpConnection as t, parseCdpEndpointValue as u };
+export { init_CdpEndpoint as a, withCdpDiscoveryDeadline as c, CdpCommandRejection as d, init_CdpCommandRejection as f, hasCdpTargetWebSocket as i, CdpConnection as l, discoverCdpBrowserSocket as n, parseCdpEndpointValue as o, discoverCdpEndpoint as r, readCdpJson as s, cdpTargetWebSocket as t, init_CdpConnection as u };

package/dist/mcp/{CdpOptionalCommand-BPjRD9Kz.js → CdpOptionalCommand-PZZhlqxv.js}

@@ -1,6 +1,6 @@
 import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
-import { c as classifyBrowserCompleteness, l as init_browserCompleteness } from "./browserObservationSchemas-tgqjH7aA.js";
-import { i as init_CdpCommandRejection, n as init_CdpConnection, r as CdpCommandRejection } from "./CdpConnection-BpDfz4MK.js";
+import { c as classifyBrowserCompleteness, l as init_browserCompleteness } from "./browserObservationSchemas-DwGGxBpu.js";
+import { d as CdpCommandRejection, f as init_CdpCommandRejection, u as init_CdpConnection } from "./CdpEndpoint-BrhMhpSi.js";
 
 //#region dist/browser/CdpCaptureCompleteness.js
 var EVENT_SECTIONS, POLICY_REASONS, CdpCaptureCompleteness, emptyDropped;