rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{BoundedFileBytes-BU30odTm.js → BoundedFileBytes-DRtiQNAQ.js}

@@ -4,7 +4,11 @@ import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
 var readBoundedFileBytes;
 function init_BoundedFileBytes() {
 	return (init_BoundedFileBytes = __esmMin((() => {
-		readBoundedFileBytes = async (handle, maxBytes, signal, expectedSize) => {
+		readBoundedFileBytes = async (handle, maxBytes, signal, expectedSize, cancellationFailure) => {
+			const assertActive = () => {
+				if (signal?.aborted && cancellationFailure !== undefined) throw cancellationFailure(signal.reason);
+				signal?.throwIfAborted();
+			};
 			if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new RangeError("File byte limit must be a nonnegative safe integer");
 			if (expectedSize !== undefined && (!Number.isSafeInteger(expectedSize) || expectedSize < 0 || expectedSize > maxBytes)) throw new RangeError("Expected file size must fit the byte limit");
 			if (expectedSize === undefined) {
@@ -12,7 +16,7 @@ function init_BoundedFileBytes() {
 				const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes + 1));
 				let total = 0;
 				for (;;) {
-					signal?.throwIfAborted();
+					assertActive();
 					const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, maxBytes - total + 1), null);
 					if (bytesRead === 0) return Buffer.concat(chunks, total);
 					total += bytesRead;
@@ -24,7 +28,7 @@ function init_BoundedFileBytes() {
 			if (expectedSize === 0) return buffer;
 			let total = 0;
 			for (;;) {
-				signal?.throwIfAborted();
+				assertActive();
 				const { bytesRead } = await handle.read(buffer, total, expectedSize - total, null);
 				if (bytesRead === 0) return buffer.subarray(0, total);
 				total += bytesRead;

package/dist/cli-runtime/{CdpTargetSession-DGX5pV9w.js → CdpTargetSession-CQ08KHbh.js}

@@ -1,7 +1,10 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { WEB_RUNTIME_LIMITS, init_browserObservation, init_urlComponents, init_webRuntime, sanitizeBrowserUrl, urlDeclaresQueryOrFragment } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
-import { AnalysisCancelledError, AnalysisError, init_analysisErrorBase, init_analysisErrorCore } from "./errorSchemas-CTRmvMl3.js";
-import { BrowserObservationError, init_browserObservationError } from "./browserObservationError-Dx6xRTjb.js";
+import { WEB_RUNTIME_LIMITS, init_browserObservation, init_urlComponents, init_webRuntime, sanitizeBrowserUrl, urlDeclaresQueryOrFragment } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { AnalysisCancelledError, AnalysisError, init_analysisErrorBase, init_analysisErrorCore } from "./errorSchemas-Ixz_q7qt.js";
+import { AnalysisCleanupLease, AnalysisCleanupLeaseGroup, init_AnalysisCleanupLease } from "./AnalysisCleanupLease-CWfTGYKd.js";
+import { BrowserObservationError, init_browserObservationError } from "./cliResultOutput-10sd6xGx.js";
+import { analysisErrorWithCleanupFailure, init_analysisErrorCleanup } from "./analysisErrorCleanup-COdAmDsb.js";
+import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-BhsJyAhk.js";
 import { init_safeJson, safeParseJson } from "./safeJson-DKKACtdy.js";
 import { z } from "zod";
 import { request } from "node:http";
@@ -312,7 +315,7 @@ function init_CdpCommandRejection() {
 
 //#endregion
 //#region dist/browser/CdpConnection.js
-var MAX_WEBSOCKET_PAYLOAD_BYTES, CdpConnection, rawText, isRecord, waitForOpen, terminateSocket;
+var MAX_WEBSOCKET_PAYLOAD_BYTES, CdpConnection, socketIsClosed, rawText, isRecord, waitForOpen, terminateSocket;
 function init_CdpConnection() {
 	return (init_CdpConnection = __esmMin((() => {
 		init_analysisErrorCore();
@@ -344,7 +347,7 @@ function init_CdpConnection() {
 				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) {
+			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)}.`);
@@ -353,8 +356,26 @@ function init_CdpConnection() {
 					maxPayload: maxPayloadBytes,
 					perMessageDeflate: false
 				});
-				await waitForOpen(socket, operation, signal);
-				return new CdpConnection(socket, operation, maxPayloadBytes);
+				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) {
@@ -379,35 +400,44 @@ function init_CdpConnection() {
 				this.#protocolFailureListeners.add(listener);
 				return () => this.#protocolFailureListeners.delete(listener);
 			}
-			/** Execute one command, optionally within a flat target session. */
+			/** 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;
-						pending.removeAbort();
-						this.#pending.delete(id);
+						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,
-						removeAbort: () => signal?.removeEventListener("abort", onAbort)
+						dispose: () => {
+							clearTimeout(timer);
+							signal?.removeEventListener("abort", onAbort);
+						}
 					});
-					this.socket.send(JSON.stringify({
-						id,
-						method,
-						params,
-						...sessionId === undefined ? {} : { sessionId }
-					}), (error) => {
+					this.socket.send(message, (error) => {
 						if (error === undefined || error === null) return;
 						const pending = this.#pending.get(id);
 						if (pending === undefined) return;
@@ -427,17 +457,52 @@ function init_CdpConnection() {
 			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", () => {
+				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);
-						resolve();
-					});
-					this.socket.close();
+						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) {
@@ -476,7 +541,8 @@ function init_CdpConnection() {
 				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) {
+				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;
 				}
@@ -498,7 +564,7 @@ function init_CdpConnection() {
 				pending.reject(new CdpCommandRejection(this.operation, pending.method, reported.code, reported.message));
 			}
 			#complete(id, pending) {
-				pending.removeAbort();
+				pending.dispose();
 				this.#pending.delete(id);
 			}
 			#failPending(reason) {
@@ -528,6 +594,7 @@ function init_CdpConnection() {
 				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) => {
@@ -547,11 +614,17 @@ function init_CdpConnection() {
 				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);
@@ -559,48 +632,239 @@ function init_CdpConnection() {
 			if (signal?.aborted === true) onAbort();
 		});
 		terminateSocket = (socket) => {
-			socket.once("error", () => undefined);
-			socket.terminate();
+			try {
+				socket.terminate();
+			} catch {}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpTargetSessionOwner.js
+var CdpTransportCleanupFailure, bindCdpTransportCleanup, CdpTargetSessionOwner, cleanupError, aggregateCleanupFailures;
+function init_CdpTargetSessionOwner() {
+	return (init_CdpTargetSessionOwner = __esmMin((() => {
+		init_AnalysisCleanupLease();
+		init_analysisErrorBase();
+		init_providerCleanupError();
+		init_analysisErrorCore();
+		init_analysisErrorCleanup();
+		init_CdpConnection();
+		CdpTransportCleanupFailure = class extends ProviderCleanupError {
+			cleanupLeases;
+			constructor(cleanupLeases, failure) {
+				super("rea-cdp-browser", failure.resources, failure.diagnostics, {
+					operation: failure.operation,
+					cause: failure.cause
+				});
+				this.cleanupLeases = cleanupLeases;
+				new AnalysisCleanupLeaseGroup(this, cleanupLeases);
+			}
+		};
+		bindCdpTransportCleanup = (cause, failure) => {
+			if (cause instanceof CdpTransportCleanupFailure) new AnalysisCleanupLeaseGroup(failure, cause.cleanupLeases);
+			return failure;
+		};
+		CdpTargetSessionOwner = class {
+			#connections = new Map();
+			#closing = false;
+			#admissions = 0;
+			#closePromise;
+			#admissionWaiters = new Set();
+			/** Admit and own one WebSocket from handshake completion onward. */
+			async connect(url, operation, options, resource, limits) {
+				if (this.#closing) throw new ProviderCleanupError("rea-cdp-browser", [resource], { reason: "CDP provider is closing and cannot admit another session." }, { operation });
+				await this.retryPending();
+				if (this.#closing) throw new ProviderCleanupError("rea-cdp-browser", [resource], { reason: "CDP provider is closing and cannot admit another session." }, { operation });
+				if (options.signal?.aborted === true) throw new AnalysisCancelledError(operation, { cause: options.signal.reason });
+				this.#admissions += 1;
+				let connection;
+				try {
+					return await CdpConnection.connect(url, operation, options.signal, limits, (opened) => {
+						connection = opened;
+						this.register(opened, operation, resource);
+					});
+				} catch (cause) {
+					if (connection === undefined) throw cause;
+					try {
+						await this.finish(connection);
+					} catch (cleanupCause) {
+						if (cause instanceof AnalysisError && cleanupCause instanceof AnalysisError) throw bindCdpTransportCleanup(cleanupCause, analysisErrorWithCleanupFailure(cause, cleanupCause, operation));
+						throw new AggregateError([cause, cleanupCause], `CDP operation ${operation} failed during handshake and cleanup remains incomplete.`, { cause });
+					}
+					throw cause;
+				} finally {
+					this.#admissions -= 1;
+					if (this.#admissions === 0) {
+						for (const resolve of this.#admissionWaiters) resolve();
+						this.#admissionWaiters.clear();
+					}
+				}
+			}
+			/** Register synchronously before awaiting the WebSocket handshake. */
+			register(connection, operation, resource) {
+				let settle = () => undefined;
+				const settled = new Promise((resolve) => {
+					settle = resolve;
+				});
+				this.#connections.set(connection, {
+					connection,
+					operation,
+					resource,
+					cleanupLease: new AnalysisCleanupLease(() => connection.close(), [resource]),
+					active: true,
+					settled,
+					settle,
+					cleanup: undefined,
+					cleanupAttempted: false,
+					failure: undefined
+				});
+			}
+			/** Finish one admitted operation, retaining a failed transport for retry. */
+			async finish(connection, cleanup) {
+				const record = this.#connections.get(connection);
+				if (record === undefined) return;
+				if (record.failure !== undefined) throw record.failure;
+				record.cleanup ??= cleanup;
+				try {
+					if (!record.cleanupAttempted && record.cleanup !== undefined) {
+						record.cleanupAttempted = true;
+						await record.cleanup();
+					}
+					await record.cleanupLease.release();
+					this.#connections.delete(connection);
+				} catch (cause) {
+					const failure = cleanupError(record, cause);
+					record.failure = failure;
+					throw failure;
+				} finally {
+					record.active = false;
+					record.settle();
+				}
+			}
+			/** Retry only retained failed transports; active peers finish their own cleanup. */
+			async close() {
+				this.#closing = true;
+				this.#closePromise ??= this.#closeAll().catch((cause) => {
+					this.#closePromise = undefined;
+					throw cause;
+				});
+				return await this.#closePromise;
+			}
+			/** Retry retained failures without touching concurrently active sessions. */
+			async retryPending() {
+				const failures = [];
+				for (const record of this.#connections.values()) {
+					if (record.active || record.failure === undefined) continue;
+					try {
+						await record.cleanupLease.release();
+						this.#connections.delete(record.connection);
+					} catch (cause) {
+						const failure = cleanupError(record, cause);
+						record.failure = failure;
+						failures.push(failure);
+					}
+				}
+				if (failures.length === 1) throw failures[0];
+				if (failures.length > 1) throw aggregateCleanupFailures(failures);
+			}
+			async #closeAll() {
+				while (this.#admissions > 0) await new Promise((resolve) => this.#admissionWaiters.add(resolve));
+				while (true) {
+					const active = [...this.#connections.values()].filter(({ active }) => active);
+					if (active.length === 0) break;
+					await Promise.all(active.map(({ settled }) => settled));
+				}
+				const failures = [];
+				for (const record of this.#connections.values()) {
+					try {
+						await record.cleanupLease.release();
+						this.#connections.delete(record.connection);
+					} catch (cause) {
+						const failure = cleanupError(record, cause);
+						record.failure = failure;
+						failures.push(failure);
+					}
+				}
+				if (failures.length === 1) throw failures[0];
+				if (failures.length > 1) throw aggregateCleanupFailures(failures);
+			}
 		};
+		cleanupError = (record, cause) => new CdpTransportCleanupFailure([record.cleanupLease], {
+			resources: [record.resource],
+			operation: record.operation,
+			cause,
+			diagnostics: { reason: cause instanceof AnalysisError ? cause.userMessage ?? cause.message : cause instanceof Error ? cause.message : String(cause) }
+		});
+		aggregateCleanupFailures = (failures) => new CdpTransportCleanupFailure(failures.flatMap((failure) => failure.cleanupLeases), {
+			resources: failures.flatMap(({ cleanupResources }) => cleanupResources),
+			operation: "close_cdp_transports",
+			cause: new AggregateError(failures, "One or more REA-owned CDP transports remain open."),
+			diagnostics: { failures: failures.map(({ message, diagnostics }) => ({
+				message,
+				diagnostics: diagnostics ?? {}
+			})) }
+		});
 	})))();
 }
 
 //#endregion
 //#region dist/browser/CdpTargetSession.js
-var openCdpEndpoint, openCdpTargetSession, attachCdpTargetSession, closeCdpTargetSession, attachedSessionId;
+var openCdpEndpoint, openCdpTargetSession, attachCdpTargetSession, combineOpenFailure, closeCdpTargetSession, cleanupCdpTargetCommands, attachedSessionId;
 function init_CdpTargetSession() {
 	return (init_CdpTargetSession = __esmMin((() => {
+		init_analysisErrorBase();
+		init_analysisErrorCleanup();
 		init_browserObservationError();
 		init_CdpConnection();
+		init_CdpTargetSessionOwner();
 		init_CdpEndpoint();
-		openCdpEndpoint = async (endpoint, operation, signal, timeoutMs) => {
+		openCdpEndpoint = async (endpoint, operation, signal, timeoutMs, owner) => {
 			if (endpoint.transport === "http_discovery") return {
 				discovery: await discoverCdpEndpoint(endpoint.url, operation, signal),
 				connection: undefined
 			};
 			return await withCdpDiscoveryDeadline(operation, signal, async (deadlineSignal) => {
-				const connection = await CdpConnection.connect(endpoint.url, operation, deadlineSignal);
+				const connection = owner === undefined ? await CdpConnection.connect(endpoint.url, operation, deadlineSignal) : await owner.connect(endpoint.url, operation, { signal: deadlineSignal }, "browser-endpoint");
 				try {
 					return {
 						discovery: await discoverCdpBrowserSocket(connection, endpoint.url, operation, deadlineSignal),
 						connection
 					};
 				} catch (cause) {
-					await connection.close();
+					if (owner === undefined) {
+						await connection.close();
+						throw cause;
+					}
+					try {
+						await owner.finish(connection);
+					} catch (cleanupCause) {
+						throw combineOpenFailure(cause, cleanupCause, operation);
+					}
 					throw cause;
 				}
 			}, timeoutMs);
 		};
-		openCdpTargetSession = async (discovery, target, operation, signal, limits) => {
+		openCdpTargetSession = async (discovery, target, operation, signal, limits, owner) => {
 			const webSocket = cdpTargetWebSocket(discovery, target, operation);
-			const connection = await CdpConnection.connect(webSocket.url, operation, signal, limits);
+			const connection = owner === undefined ? await CdpConnection.connect(webSocket.url, operation, signal, limits) : await owner.connect(webSocket.url, operation, signal === undefined ? {} : { signal }, target.id, limits);
 			if (webSocket.scope === "page") return {
 				connection,
 				sessionId: undefined
 			};
-			return await attachCdpTargetSession(connection, target, operation, signal);
+			try {
+				return await attachCdpTargetSession(connection, target, operation, signal, owner);
+			} catch (cause) {
+				if (owner === undefined) throw cause;
+				try {
+					await owner.finish(connection);
+				} catch (cleanupCause) {
+					throw combineOpenFailure(cause, cleanupCause, operation);
+				}
+				throw cause;
+			}
 		};
-		attachCdpTargetSession = async (connection, target, operation, signal) => {
+		attachCdpTargetSession = async (connection, target, operation, signal, owner) => {
 			try {
 				const attached = await connection.send("Target.attachToTarget", {
 					targetId: target.id,
@@ -611,11 +875,23 @@ function init_CdpTargetSession() {
 					sessionId: attachedSessionId(attached, operation)
 				};
 			} catch (cause) {
-				await connection.close();
+				if (owner === undefined) {
+					await connection.close();
+					throw cause;
+				}
 				throw cause;
 			}
 		};
-		closeCdpTargetSession = async (targetSession, enabledDomains, signal) => {
+		combineOpenFailure = (primary, cleanup, operation) => primary instanceof AnalysisError && cleanup instanceof AnalysisError ? bindCdpTransportCleanup(cleanup, analysisErrorWithCleanupFailure(primary, cleanup, operation)) : new AggregateError([primary, cleanup], `CDP operation ${operation} failed and its transport cleanup is incomplete.`, { cause: primary });
+		closeCdpTargetSession = async (targetSession, enabledDomains, signal, owner) => {
+			if (owner !== undefined) {
+				await owner.finish(targetSession.connection, () => cleanupCdpTargetCommands(targetSession, enabledDomains, signal));
+				return;
+			}
+			await cleanupCdpTargetCommands(targetSession, enabledDomains, signal);
+			await targetSession.connection.close();
+		};
+		cleanupCdpTargetCommands = async (targetSession, enabledDomains, signal) => {
 			const { connection, sessionId } = targetSession;
 			const cleanup = new AbortController();
 			const domainSignal = signal === undefined ? cleanup.signal : AbortSignal.any([cleanup.signal, signal]);
@@ -636,7 +912,6 @@ function init_CdpTargetSession() {
 			} finally {
 				clearTimeout(timeout);
 				cleanup.abort();
-				await connection.close();
 			}
 		};
 		attachedSessionId = (value, operation) => {
@@ -647,4 +922,4 @@ function init_CdpTargetSession() {
 }
 
 //#endregion
-export { CdpCommandRejection, CdpConnection, attachCdpTargetSession, closeCdpTargetSession, discoverCdpEndpoint, hasCdpTargetWebSocket, init_CdpCommandRejection, init_CdpConnection, init_CdpEndpoint, init_CdpTargetSession, openCdpEndpoint, openCdpTargetSession, parseCdpEndpointValue, readCdpJson, withCdpDiscoveryDeadline };
+export { CdpCommandRejection, CdpConnection, CdpTargetSessionOwner, attachCdpTargetSession, bindCdpTransportCleanup, closeCdpTargetSession, discoverCdpEndpoint, hasCdpTargetWebSocket, init_CdpCommandRejection, init_CdpConnection, init_CdpEndpoint, init_CdpTargetSession, init_CdpTargetSessionOwner, openCdpEndpoint, openCdpTargetSession, parseCdpEndpointValue, readCdpJson, withCdpDiscoveryDeadline };