rea-agents 6.5.0 → 6.7.0

package/dist/browser/CdpElectronProvider.js

@@ -1,5 +1,6 @@
 import { electronPageInspectionSchema, electronTargetListSchema, } from "../domain/javascript/electronObservation.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err, ok } from "../domain/result.js";
@@ -9,8 +10,15 @@ import { inspectCdpElectronPage } from "./CdpElectronInspection.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 import { CDP_ELECTRON_PROVIDER_IDENTITY } from "./providerIdentities.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
+import { CdpTargetSessionOwner, bindCdpTransportCleanup, } from "./CdpTargetSessionOwner.js";
 /** Passive Electron provider for local file pages exposed by loopback CDP. */
 export class CdpElectronProvider {
+    #owner = new CdpTargetSessionOwner();
+    close() {
+        return this.#owner.close();
+    }
     identity() {
         return CDP_ELECTRON_PROVIDER_IDENTITY;
     }
@@ -72,11 +80,13 @@ export class CdpElectronProvider {
     }
     async inspectPage(input, options = {}) {
         let targetSession;
+        let cleanupFailure;
+        let result;
         try {
             const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "inspect_electron_page", options.signal);
             const target = await authorizeTarget(discovery.targets, input.target_id);
-            targetSession = await openCdpTargetSession(discovery, target, "inspect_electron_page", options.signal);
-            return ok(electronPageInspectionSchema.parse(await inspectCdpElectronPage({
+            targetSession = await openCdpTargetSession(discovery, target, "inspect_electron_page", options.signal, undefined, this.#owner);
+            result = ok(electronPageInspectionSchema.parse(await inspectCdpElectronPage({
                 connection: targetSession.connection,
                 sessionId: targetSession.sessionId,
                 discovery,
@@ -89,12 +99,54 @@ export class CdpElectronProvider {
             })));
         }
         catch (cause) {
-            return err(providerError(cause, "inspect_electron_page"));
+            result = err(providerError(cause, "inspect_electron_page"));
         }
         finally {
             if (targetSession !== undefined)
-                await closeCdpTargetSession(targetSession, ["Debugger", "Runtime", "Page"], options.signal);
+                try {
+                    await closeCdpTargetSession(targetSession, ["Debugger", "Runtime", "Page"], options.signal, this.#owner);
+                }
+                catch (cause) {
+                    cleanupFailure =
+                        cause instanceof AnalysisError
+                            ? cause
+                            : new ProviderCleanupError(CDP_ELECTRON_PROVIDER_IDENTITY.id, [input.target_id], {
+                                reason: cause instanceof Error ? cause.message : String(cause),
+                            }, { operation: "inspect_electron_page", cause });
+                }
+        }
+        const finalCancellation = result.ok && options.signal?.aborted === true
+            ? new AnalysisCancelledError("inspect_electron_page", {
+                cause: options.signal.reason,
+                partialObservation: {
+                    kind: "electron-page-observation",
+                    inspection: result.value,
+                    cleanup: cleanupFailure === undefined
+                        ? "transport-closed"
+                        : "incomplete",
+                },
+            })
+            : undefined;
+        if (cleanupFailure !== undefined) {
+            if (finalCancellation !== undefined)
+                return err(bindCdpTransportCleanup(cleanupFailure, analysisErrorWithCleanupFailure(finalCancellation, cleanupFailure, "inspect_electron_page")));
+            if (!result.ok)
+                return err(bindCdpTransportCleanup(cleanupFailure, analysisErrorWithCleanupFailure(result.error, cleanupFailure, "inspect_electron_page")));
+            return err(bindCdpTransportCleanup(cleanupFailure, new ProviderCleanupError(CDP_ELECTRON_PROVIDER_IDENTITY.id, cleanupFailure.cleanupResources, { cleanup_error: cleanupFailure.message }, {
+                operation: "inspect_electron_page",
+                cause: cleanupFailure,
+                partialObservation: {
+                    kind: "electron-page-observation",
+                    inspection: result.value,
+                    cleanup: "incomplete",
+                },
+            })));
         }
+        if (!result.ok)
+            return result;
+        if (finalCancellation !== undefined)
+            return err(finalCancellation);
+        return result;
     }
 }
 const authorizeTarget = async (targets, targetId) => {

package/dist/browser/CdpElectronScriptEvents.js

@@ -30,12 +30,15 @@ export const ingestElectronScriptEvent = (input) => {
         input.completeness.exclude("scripts", "unattributed_origin");
         return;
     }
+    const contextKey = executionContextKey(value?.executionContextId);
     input.scripts.push({
         scriptId,
         rawUrl,
         ...scriptMetadataValues(value),
         language: cdpStringValue(value?.scriptLanguage) ?? null,
-        executionContextKey: executionContextKey(value?.executionContextId),
+        frameId: contextKey === null
+            ? null
+            : (input.executionContextFrames.get(contextKey) ?? null),
     });
 };
 const retainExecutionContext = (event, frames) => {

package/dist/browser/CdpElectronScripts.js

@@ -15,12 +15,9 @@ export const captureElectronScripts = async (input) => {
             input.completeness.exclude("scripts", "out_of_target_scope");
             continue;
         }
-        const mappedFrame = script.executionContextKey === null
-            ? undefined
-            : input.executionContextFrames.get(script.executionContextKey);
         const identity = {
-            frame_id: mappedFrame !== undefined && input.frameIds.has(mappedFrame)
-                ? mappedFrame
+            frame_id: script.frameId !== null && input.frameIds.has(script.frameId)
+                ? script.frameId
                 : null,
             file_path: path,
             cdp_hash: script.hash,

package/dist/browser/CdpElectronWorkers.js

@@ -1,5 +1,5 @@
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { recordValue, cdpStringValue } from "./CdpCaptureValues.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
@@ -15,7 +15,18 @@ export const captureElectronWorkers = async (input) => {
         return [];
     }
     const workers = [];
-    for (const target of recordsValue(recordValue(result)?.targetInfos)) {
+    // A missing target list or a non-record entry is unreadable, not empty.
+    const targetInfos = recordValue(result)?.targetInfos;
+    if (!Array.isArray(targetInfos)) {
+        input.completeness.exclude("workers", "invalid_protocol_value", null);
+        return [];
+    }
+    for (const entry of targetInfos) {
+        const target = recordValue(entry);
+        if (target === undefined) {
+            input.completeness.exclude("workers", "invalid_protocol_value");
+            continue;
+        }
         const type = cdpStringValue(target.type) ?? "";
         if (!type.includes("worker"))
             continue;

package/dist/browser/CdpPageCapture.js

@@ -282,10 +282,11 @@ const accessibilityForFrames = async (state, frames) => {
     const capture = captureAccessibility(results, {
         includeText: context.input.include_accessibility_text,
         ...(results.length === 0 && unavailable ? { unavailable: true } : {}),
+        completeness: events.completeness,
     });
     if (!context.input.include_accessibility_text)
         events.completeness.exclude("accessibility", "not_approved", capture.textCapture.excluded_fields);
-    if (capture.treeIncomplete)
+    if (capture.hasUnobservedChildren)
         events.completeness.truncate("accessibility");
     return capture;
 };

package/dist/browser/CdpPageCaptureScripts.js

@@ -1,18 +1,19 @@
-import { reconcileCapturedWebScript, stableWebScriptKey, } from "../domain/webInventory.js";
+import { createCapturedWebScriptReconciler, stableWebScriptKey, } from "../domain/webInventory.js";
 import { requiredScriptSource, sourceExcluded, sourceResult, } from "./CdpCaptureValues.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 export const captureScripts = async (options) => {
     const { context, events, rawResources, resources, frameIds } = options;
-    const state = {
-        context,
-        events,
-        frameIds,
-        rawResources,
-        resources,
-    };
+    let state;
     const drafts = [];
-    for (const script of events.scripts.values())
+    for (const script of events.scripts.values()) {
+        state ??= {
+            context,
+            events,
+            frameIds,
+            reconcileResource: createCapturedWebScriptReconciler(rawResources, resources),
+        };
         drafts.push(await buildScriptDraft(script, state));
+    }
     if (!context.input.include_script_sources)
         events.completeness.exclude("script_sources", "not_approved", events.scripts.size);
     return keyAndBuildInventory(drafts, events.scripts.size);
@@ -35,7 +36,10 @@ const buildScriptDraft = async (script, state) => {
         item: {
             ...inventoryScript,
             origin: script.origin,
-            resource_reconciliation: reconcileCapturedWebScript({ ...inventoryScript, rawUrl: script.rawUrl }, state.rawResources, state.resources),
+            resource_reconciliation: state.reconcileResource({
+                ...inventoryScript,
+                rawUrl: script.rawUrl,
+            }),
             source,
         },
         sourceMapRawUrl: script.sourceMapRawUrl,

package/dist/browser/CdpPageCaptureWorkers.js

@@ -1,4 +1,4 @@
-import { allowedSanitizedUrl, isHttpUrl, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { admitRecords, allowedSanitizedUrl, isHttpUrl, recordValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 export const captureWorkers = async (input, frameIds) => {
     const { context, allowedOrigins, limitations, events } = input;
@@ -7,14 +7,47 @@ export const captureWorkers = async (input, frameIds) => {
     const items = [];
     if (result === undefined)
         completeness.unavailable("workers");
-    for (const target of recordsValue(recordValue(result)?.targetInfos)) {
-        const type = cdpStringValue(target.type) ?? "";
-        const url = allowedSanitizedUrl(target.url, allowedOrigins);
-        const relatedToPage = cdpStringValue(target.openerId) === context.target.id ||
-            (cdpStringValue(target.parentFrameId) !== undefined &&
-                frameIds.has(cdpStringValue(target.parentFrameId) ?? ""));
+    const targets = admitRecords(recordValue(result)?.targetInfos);
+    if (result !== undefined && targets === undefined) {
+        completeness.exclude("workers", "invalid_protocol_value", null);
+        return items;
+    }
+    let malformedEntries = 0;
+    for (const entry of targets ?? []) {
+        const target = recordValue(entry);
+        if (target === undefined) {
+            malformedEntries += 1;
+            continue;
+        }
+        const type = cdpStringValue(target.type);
+        if (type === undefined || type.length === 0) {
+            malformedEntries += 1;
+            continue;
+        }
         if (!type.includes("worker"))
             continue;
+        const targetId = cdpStringValue(target.targetId);
+        if (targetId === undefined ||
+            targetId.length === 0 ||
+            typeof target.attached !== "boolean" ||
+            typeof target.url !== "string") {
+            malformedEntries += 1;
+            continue;
+        }
+        const openerId = target.openerId === undefined
+            ? undefined
+            : cdpStringValue(target.openerId);
+        const parentFrameId = target.parentFrameId === undefined
+            ? undefined
+            : cdpStringValue(target.parentFrameId);
+        if ((target.openerId !== undefined && openerId === undefined) ||
+            (target.parentFrameId !== undefined && parentFrameId === undefined)) {
+            malformedEntries += 1;
+            continue;
+        }
+        const url = allowedSanitizedUrl(target.url, allowedOrigins);
+        const relatedToPage = openerId === context.target.id ||
+            (parentFrameId !== undefined && frameIds.has(parentFrameId));
         if (!relatedToPage) {
             completeness.exclude("workers", "out_of_target_scope");
             continue;
@@ -28,19 +61,17 @@ export const captureWorkers = async (input, frameIds) => {
                     : "unsupported_url");
             continue;
         }
-        if (typeof target.attached !== "boolean") {
-            completeness.exclude("workers", "invalid_protocol_value");
-            continue;
-        }
         items.push({
-            target_id: cdpStringValue(target.targetId) ?? "",
+            target_id: targetId,
             type,
             url: url.url,
             origin: url.origin,
             attached: target.attached,
-            opener_target_id: cdpStringValue(target.openerId) ?? null,
-            parent_frame_id: cdpStringValue(target.parentFrameId) ?? null,
+            opener_target_id: openerId ?? null,
+            parent_frame_id: parentFrameId ?? null,
         });
     }
+    if (malformedEntries > 0)
+        completeness.exclude("workers", "invalid_protocol_value", malformedEntries);
     return items;
 };

package/dist/browser/CdpSafeMetadata.js

@@ -1,5 +1,6 @@
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { cdpStringValue } from "./CdpCaptureValues.js";
+import { structuredFieldToken } from "./StructuredFieldToken.js";
 /** Normalize an allowlisted subset of response metadata and discard raw headers. */
 export const safeResponseMetadata = (requestId, url, response, allowedOrigins) => {
     const headers = normalizedHeaders(response.headers);
@@ -22,8 +23,8 @@ export const safeResponseMetadata = (requestId, url, response, allowedOrigins) =
             csp,
             links,
             policies: {
-                coop: policyToken(headers.get("cross-origin-opener-policy")),
-                coep: policyToken(headers.get("cross-origin-embedder-policy")),
+                coop: structuredFieldToken(headers.get("cross-origin-opener-policy")),
+                coep: structuredFieldToken(headers.get("cross-origin-embedder-policy")),
                 corp: policyToken(headers.get("cross-origin-resource-policy")),
                 referrer_policy: referrerPolicy(headers.get("referrer-policy")),
                 x_content_type_options: policyToken(headers.get("x-content-type-options")),
@@ -136,23 +137,26 @@ const schemeOf = (baseUrl) => {
 };
 const parseLinks = (value, baseUrl, allowedOrigins) => {
     const links = [];
-    for (const entry of splitLinkHeader(value ?? "")) {
-        const match = /^\s*<([^>]*)>(.*)$/u.exec(entry);
-        if (match === null)
-            continue;
-        const parameters = linkParameters(match[2] ?? "");
-        const destination = safeDestination(match[1] ?? "", baseUrl, allowedOrigins);
-        links.push({
-            href: destination.url,
-            destination_scope: destination.scope,
-            rel: (parameters.get("rel") ?? "")
-                .toLowerCase()
-                .split(/\s+/u)
-                .filter(Boolean),
-            as: boundedHeader(parameters.get("as")),
-            type: boundedHeader(parameters.get("type")),
-            crossorigin: boundedHeader(parameters.get("crossorigin")),
-        });
+    // CDP joins repeated field lines with LF; quoted delimiters belong to one line.
+    for (const line of (value ?? "").split(/\r?\n/u)) {
+        for (const entry of splitLinkHeader(line)) {
+            const match = /^\s*<([^>]*)>(.*)$/u.exec(entry);
+            if (match === null)
+                continue;
+            const parameters = linkParameters(match[2] ?? "");
+            const destination = safeDestination(match[1] ?? "", baseUrl, allowedOrigins);
+            links.push({
+                href: destination.url,
+                destination_scope: destination.scope,
+                rel: (parameters.get("rel") ?? "")
+                    .toLowerCase()
+                    .split(/\s+/u)
+                    .filter(Boolean),
+                as: boundedHeader(parameters.get("as")),
+                type: boundedHeader(parameters.get("type")),
+                crossorigin: boundedHeader(parameters.get("crossorigin")),
+            });
+        }
     }
     return links;
 };

package/dist/browser/CdpSnapshotNodes.js

@@ -0,0 +1,103 @@
+import { err, ok } from "../domain/result.js";
+import { numberValue, recordValue } from "./CdpCaptureValues.js";
+import { cdpSnapshotString, cdpSnapshotValueString, } from "./CdpSnapshotStrings.js";
+const integer = (value) => {
+    const parsed = numberValue(value);
+    return parsed !== undefined && Number.isSafeInteger(parsed)
+        ? parsed
+        : undefined;
+};
+const attributes = (value, strings) => {
+    if (!Array.isArray(value) || value.length % 2 !== 0)
+        return undefined;
+    const pairs = [];
+    for (let offset = 0; offset < value.length; offset += 2) {
+        const name = cdpSnapshotString(strings, value[offset]);
+        const text = cdpSnapshotValueString(strings, value[offset + 1]);
+        if (name === undefined || text === undefined)
+            return undefined;
+        pairs.push([name, text]);
+    }
+    return pairs;
+};
+/** Remove only cyclic parent facts; descendants keep their directly observed links. */
+const invalidateParentCycles = (parents) => {
+    const state = new Uint8Array(parents.length);
+    const path = [];
+    for (let start = 0; start < parents.length; start += 1) {
+        if (state[start] !== 0)
+            continue;
+        path.length = 0;
+        let cursor = start;
+        while (cursor >= 0 && state[cursor] === 0) {
+            state[cursor] = 1;
+            path.push(cursor);
+            // Unknown ancestry ends this walk without inventing a root fact.
+            cursor = parents[cursor] ?? -1;
+        }
+        if (cursor >= 0 && state[cursor] === 1)
+            for (let index = path.indexOf(cursor); index < path.length; index += 1)
+                parents[path[index]] = undefined;
+        for (const index of path)
+            state[index] = 2;
+    }
+};
+/** One boundary owns aligned arrays, string references and parent validity. */
+export const snapshotDocumentNodes = (value, strings) => {
+    const raw = recordValue(value);
+    if (raw === undefined ||
+        !Array.isArray(raw.nodeType) ||
+        !Array.isArray(raw.nodeName) ||
+        !Array.isArray(raw.nodeValue) ||
+        !Array.isArray(raw.parentIndex) ||
+        !Array.isArray(raw.attributes))
+        return undefined;
+    const count = raw.nodeType.length;
+    if (raw.nodeName.length !== count ||
+        raw.nodeValue.length !== count ||
+        raw.parentIndex.length !== count)
+        return undefined;
+    const parents = raw.parentIndex.map((value, index) => {
+        const parent = integer(value);
+        return parent !== undefined &&
+            parent >= -1 &&
+            parent < count &&
+            parent !== index
+            ? parent
+            : undefined;
+    });
+    invalidateParentCycles(parents);
+    const backend = Array.isArray(raw.backendNodeId) ? raw.backendNodeId : [];
+    return {
+        nodeTypes: raw.nodeType.map((value) => {
+            const type = integer(value);
+            return type !== undefined && type >= 0 ? type : undefined;
+        }),
+        nodeNames: raw.nodeName.map((value) => cdpSnapshotString(strings, value)),
+        nodeValues: raw.nodeValue.map((value) => cdpSnapshotValueString(strings, value)),
+        parents,
+        attributes: raw.attributes
+            .slice(0, count)
+            .map((value) => attributes(value, strings)),
+        backendNodeIds: backend.slice(0, count).map((value) => {
+            const id = integer(value);
+            return id !== undefined && id > 0 ? id : undefined;
+        }),
+        excessAttributes: Math.max(0, raw.attributes.length - count),
+    };
+};
+/** Admit a DOM row from parsed facts without changing its source identity. */
+export const snapshotNodeAt = (nodes, index) => {
+    const nodeType = nodes.nodeTypes[index];
+    const nodeName = nodes.nodeNames[index];
+    const nodeValue = nodes.nodeValues[index];
+    const parent = nodes.parents[index];
+    const attributes = nodes.attributes[index];
+    return nodeType === undefined ||
+        nodeName === undefined ||
+        nodeValue === undefined ||
+        parent === undefined ||
+        attributes === undefined
+        ? err({ _tag: "InvalidCdpSnapshotNode", index })
+        : ok({ nodeType, nodeName, nodeValue, parent, attributes });
+};

package/dist/browser/CdpSnapshotStrings.js

@@ -13,9 +13,3 @@ export const cdpSnapshotString = (strings, index) => {
 export const cdpSnapshotValueString = (strings, index) => numberValue(index) === CDP_EMPTY_STRING_INDEX
     ? ""
     : cdpSnapshotString(strings, index);
-/** Whether flattened name/value attribute indexes all resolve. */
-export const cdpSnapshotAttributesResolve = (strings, attributes) => attributes.length % 2 === 0 &&
-    attributes.every((attribute, offset) => attribute !== undefined &&
-        (offset % 2 === 0
-            ? cdpSnapshotString(strings, attribute)
-            : cdpSnapshotValueString(strings, attribute)) !== undefined);

package/dist/browser/CdpTargetSession.js

@@ -1,18 +1,23 @@
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { CdpConnection } from "./CdpConnection.js";
+import { CdpTargetSessionOwner, bindCdpTransportCleanup, } from "./CdpTargetSessionOwner.js";
 import { cdpTargetWebSocket, discoverCdpBrowserSocket, discoverCdpEndpoint, withCdpDiscoveryDeadline, } from "./CdpEndpoint.js";
 /**
  * Discover one passive browser endpoint through its selected transport. A
  * browser socket's handshake and discovery share one discovery deadline.
  */
-export const openCdpEndpoint = async (endpoint, operation, signal, timeoutMs) => {
+export const 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),
@@ -20,32 +25,70 @@ export const openCdpEndpoint = async (endpoint, operation, signal, timeoutMs) =>
             };
         }
         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);
 };
 /** Open one authorized target through its supported browser or page transport. */
-export const openCdpTargetSession = async (discovery, target, operation, signal, limits) => {
+export const 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;
+    }
 };
 /** Attach one target through an open browser socket, which the session then owns. */
-export const attachCdpTargetSession = async (connection, target, operation, signal) => {
+export const attachCdpTargetSession = async (connection, target, operation, signal, owner) => {
     try {
         const attached = await connection.send("Target.attachToTarget", { targetId: target.id, flatten: true }, undefined, signal);
         return { connection, sessionId: attachedSessionId(attached, operation) };
     }
     catch (cause) {
-        await connection.close();
+        if (owner === undefined) {
+            await connection.close();
+            throw cause;
+        }
         throw cause;
     }
 };
+const 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 });
 /** Disable enabled domains, detach browser sessions, and close REA's socket. */
-export const closeCdpTargetSession = async (targetSession, enabledDomains, signal) => {
+export const 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();
+};
+const cleanupCdpTargetCommands = async (targetSession, enabledDomains, signal) => {
     const { connection, sessionId } = targetSession;
     const cleanup = new AbortController();
     const domainSignal = signal === undefined
@@ -79,7 +122,6 @@ export const closeCdpTargetSession = async (targetSession, enabledDomains, signa
     finally {
         clearTimeout(timeout);
         cleanup.abort();
-        await connection.close();
     }
 };
 const attachedSessionId = (value, operation) => {