rea-agents 6.3.0 → 6.4.0

package/dist/browser/CdpCaptureDocuments.js

@@ -1,5 +1,6 @@
 import { allowedSanitizedUrl, numberValue, recordValue, recordsValue, requiredRecord, cdpStringValue, } from "./CdpCaptureValues.js";
 import { exclusionReasonForUrl } from "./CdpCaptureEventHelpers.js";
+import { createDocumentSvgAncestry, domSvgLink } from "./CdpCaptureDomSvg.js";
 /** Normalize every allowed frame, optionally selecting a leading frame. */
 export const captureFrames = (result, allowedOrigins, maximum, completeness) => {
     const root = recordValue(recordValue(result)?.frameTree);
@@ -114,21 +115,27 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
             ? documentNodes.attributes
             : [];
         const baseIndex = nodes.length;
+        const ancestry = createDocumentSvgAncestry({
+            nodeTypes,
+            nodeNames,
+            parents,
+            strings,
+            attributes,
+        });
         total += nodeTypes.length;
         for (let index = 0; index < nodeTypes.length; index += 1) {
             const attributeIndexes = numberArray(attributes[index]);
             const parent = Math.trunc(parents[index] ?? -1);
             const nodeIndex = nodes.length;
             const nodeName = indexedString(strings, nodeNames[index]);
+            const attributeNames = uniqueAttributeNames(attributeIndexes, strings);
             nodes.push({
                 index: nodeIndex,
                 parent_index: parent < 0 ? -1 : baseIndex + parent,
                 node_type: Math.max(0, Math.trunc(nodeTypes[index] ?? 0)),
                 node_name: nodeName,
                 node_value_length: indexedString(strings, nodeValues[index]).length,
-                attribute_names: attributeIndexes
-                    .filter((_value, attributeIndex) => attributeIndex % 2 === 0)
-                    .map((value) => indexedString(strings, value)),
+                attribute_names: attributeNames,
             });
             const metadata = domMetadata({
                 strings,
@@ -139,6 +146,7 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
                 nodeIndex,
                 nodeName,
                 allowedOrigins,
+                ...domSvgLink(ancestry, index),
             });
             for (const url of metadata.urls) {
                 urls.push(url);
@@ -261,23 +269,49 @@ const indexedString = (strings, index) => {
     const integer = numberValue(index);
     return integer === undefined ? "" : (strings[Math.trunc(integer)] ?? "");
 };
+const uniqueAttributeNames = (attributeIndexes, strings) => {
+    const names = [];
+    const seen = new Set();
+    for (let index = 0; index < attributeIndexes.length; index += 2) {
+        const name = indexedString(strings, attributeIndexes[index]);
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        names.push(name);
+    }
+    return names;
+};
 const numberArray = (value) => Array.isArray(value)
     ? value.flatMap((item) => {
         const number = numberValue(item);
         return number === undefined ? [] : [number];
     })
     : [];
+// Chrome reads an SVG XLink href only when href itself is absent, and an
+// empty href still wins. HTML keeps the literal attribute name `xlink:href`.
+// XML uses any prefix bound to the XLink namespace. Both are stored as href.
+const hrefAttributeValue = (pairs, attribute, options) => {
+    const declared = pairs.get(attribute);
+    if (declared !== undefined)
+        return declared;
+    if (attribute !== "href" || !options.svgElement)
+        return undefined;
+    return options.xmlDocument ? options.xlinkHref : pairs.get("xlink:href");
+};
 const domMetadata = (options) => {
     const { strings, attributes, baseUrl, documentUrl, nodeIndex, nodeName, allowedOrigins, } = options;
     const pairs = new Map();
     for (let index = 0; index + 1 < attributes.length; index += 2) {
-        const name = indexedString(strings, attributes[index]).toLowerCase();
+        // Chrome already folds HTML names; SVG/XML names remain case-sensitive.
+        const name = indexedString(strings, attributes[index]);
         const value = indexedString(strings, attributes[index + 1]);
-        pairs.set(name, value);
+        // HTML keeps the first declaration. A later repeat must not move dom_urls.
+        if (!pairs.has(name))
+            pairs.set(name, value);
     }
     const urls = [];
     for (const attribute of domUrlAttributes) {
-        const value = pairs.get(attribute);
+        const value = hrefAttributeValue(pairs, attribute, options);
         if (value === undefined)
             continue;
         const tagName = nodeName.toLowerCase();

package/dist/browser/CdpCaptureDomSvg.js

@@ -0,0 +1,210 @@
+import { numberValue } from "./CdpCaptureValues.js";
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+const XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+const UNRESOLVED = {
+    svgElement: false,
+    xlinkHref: undefined,
+};
+const stringAt = (strings, index) => {
+    const integer = numberValue(index);
+    return integer === undefined ? "" : (strings[Math.trunc(integer)] ?? "");
+};
+const numberArray = (value) => Array.isArray(value)
+    ? value.flatMap((item) => {
+        const number = numberValue(item);
+        return number === undefined ? [] : [number];
+    })
+    : [];
+// DOMSnapshot has no namespace URI. HTML documents use uppercase `HTML` and
+// the parser's local names. XML documents preserve prefixed names and xmlns
+// declarations, including those on standalone SVG roots.
+const xmlDocument = (nodes) => {
+    const documentIndex = nodes.nodeTypes.findIndex((nodeType) => Math.trunc(nodeType) === 9);
+    if (documentIndex < 0)
+        return false;
+    for (let index = 0; index < nodes.nodeTypes.length; index += 1) {
+        if (Math.trunc(nodes.nodeTypes[index] ?? 0) !== 1)
+            continue;
+        if (Math.trunc(nodes.parents[index] ?? -1) !== documentIndex)
+            continue;
+        const name = stringAt(nodes.strings, nodes.nodeNames[index]);
+        if (name === "HTML")
+            return false;
+        if (name === "html" || name.includes(":"))
+            return true;
+        // Explicit namespaces also identify standalone SVG and other XML roots.
+        // Namespace-free synthetic snapshots retain the legacy HTML behavior.
+        const attributes = numberArray(nodes.attributes[index]);
+        return attributes.some((value, offset) => offset % 2 === 0 &&
+            xmlnsPrefix(stringAt(nodes.strings, value)) !== undefined);
+    }
+    return false;
+};
+export const createDocumentSvgAncestry = (nodes) => {
+    const xml = xmlDocument(nodes);
+    return {
+        xml,
+        nodes,
+        svgContexts: new Map(),
+        xmlLinks: xml ? resolveXmlElements(nodes) : new Map(),
+    };
+};
+export const domSvgLink = (ancestry, index) => {
+    if (!ancestry.xml) {
+        return {
+            svgElement: elementInSvgContext(index, ancestry.nodes, ancestry.svgContexts),
+            xmlDocument: false,
+            xlinkHref: undefined,
+        };
+    }
+    const resolved = ancestry.xmlLinks.get(index) ?? UNRESOLVED;
+    return {
+        svgElement: resolved.svgElement,
+        xmlDocument: true,
+        xlinkHref: resolved.xlinkHref,
+    };
+};
+// Chrome's HTML parser records SVG local names (`svg`, `foreignObject`).
+// Descendants of foreignObject are HTML until a nested `svg`.
+const elementInSvgContext = (index, nodes, contexts) => {
+    let current = index;
+    const seen = new Set();
+    let inSvg = false;
+    while (current >= 0 &&
+        current < nodes.nodeNames.length &&
+        !seen.has(current)) {
+        const cached = contexts.get(current);
+        if (cached !== undefined) {
+            inSvg = cached;
+            break;
+        }
+        seen.add(current);
+        if (stringAt(nodes.strings, nodes.nodeNames[current]) === "svg") {
+            inSvg = true;
+            break;
+        }
+        const parent = Math.trunc(nodes.parents[current] ?? -1);
+        if (parent < 0 || parent === current)
+            break;
+        if (stringAt(nodes.strings, nodes.nodeNames[parent]) === "foreignObject")
+            break;
+        current = parent;
+    }
+    // Cache the entire examined chain, including forward references and cycles,
+    // so shared ancestors are examined once per document.
+    for (const node of seen)
+        contexts.set(node, inSvg);
+    return inSvg;
+};
+// Walk parent-before-child with one mutable namespace environment. Restore
+// declarations on exit so siblings retain their own scope. Only declarations
+// on the active path are retained, rather than cumulative maps at every node.
+const resolveXmlElements = (nodes) => {
+    const children = new Map();
+    const pending = [];
+    for (let node = 0; node < nodes.nodeNames.length; node += 1) {
+        const parent = Math.trunc(nodes.parents[node] ?? -1);
+        if (parent < 0)
+            pending.push({ node });
+        else if (parent < nodes.nodeNames.length && parent !== node) {
+            const siblings = children.get(parent);
+            if (siblings === undefined)
+                children.set(parent, [node]);
+            else
+                siblings.push(node);
+        }
+    }
+    const bindings = new Map();
+    const resolved = new Map();
+    while (pending.length > 0) {
+        const step = pending.pop();
+        if (step === undefined)
+            break;
+        if ("restore" in step) {
+            for (const { prefix, previous } of step.restore) {
+                if (previous === undefined)
+                    bindings.delete(prefix);
+                else
+                    bindings.set(prefix, previous);
+            }
+            continue;
+        }
+        const { node } = step;
+        const attributes = numberArray(nodes.attributes[node]);
+        const restore = applyDeclarations(bindings, attributes, nodes.strings);
+        const svgElement = Math.trunc(nodes.nodeTypes[node] ?? 0) === 1 &&
+            elementNamespace(stringAt(nodes.strings, nodes.nodeNames[node]), bindings) === SVG_NAMESPACE;
+        resolved.set(node, {
+            svgElement,
+            xlinkHref: svgElement
+                ? xlinkHrefValue(attributes, nodes.strings, bindings)
+                : undefined,
+        });
+        pending.push({ restore });
+        for (const child of children.get(node) ?? [])
+            pending.push({ node: child });
+    }
+    // Cycles (including self-parents) and dangling chains cannot reach a root,
+    // so remain unresolved instead of deriving URLs from an invalid ancestry.
+    return resolved;
+};
+const applyDeclarations = (bindings, attributes, strings) => {
+    const restore = [];
+    const seen = new Set();
+    for (let index = 0; index + 1 < attributes.length; index += 2) {
+        const prefix = xmlnsPrefix(stringAt(strings, attributes[index]));
+        if (prefix === undefined || seen.has(prefix))
+            continue;
+        seen.add(prefix);
+        restore.push({ prefix, previous: bindings.get(prefix) });
+        const value = stringAt(strings, attributes[index + 1]);
+        if (value.length === 0)
+            bindings.delete(prefix);
+        else
+            bindings.set(prefix, value);
+    }
+    return restore;
+};
+const xmlnsPrefix = (name) => {
+    if (name === "xmlns")
+        return "";
+    if (!name.startsWith("xmlns:"))
+        return undefined;
+    const prefix = name.slice("xmlns:".length);
+    if (prefix.length === 0 || prefix === "xmlns" || prefix.includes(":"))
+        return undefined;
+    return prefix;
+};
+const elementNamespace = (nodeName, bindings) => {
+    const colon = nodeName.indexOf(":");
+    if (colon < 0)
+        return bindings.get("") ?? "";
+    const prefix = nodeName.slice(0, colon);
+    const local = nodeName.slice(colon + 1);
+    if (prefix.length === 0 ||
+        local.length === 0 ||
+        local.includes(":") ||
+        prefix === "xmlns")
+        return "";
+    return bindings.get(prefix) ?? "";
+};
+// First prefixed href bound to the XLink namespace. Duplicate names keep the
+// earlier value. Plain href is applied by the caller and wins even when empty.
+const xlinkHrefValue = (attributes, strings, bindings) => {
+    const seen = new Set();
+    for (let index = 0; index + 1 < attributes.length; index += 2) {
+        const name = stringAt(strings, attributes[index]);
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        const colon = name.indexOf(":");
+        if (colon <= 0)
+            continue;
+        const prefix = name.slice(0, colon);
+        const local = name.slice(colon + 1);
+        if (local !== "href" || bindings.get(prefix) !== XLINK_NAMESPACE)
+            continue;
+        return stringAt(strings, attributes[index + 1]);
+    }
+    return undefined;
+};

package/dist/browser/CdpCaptureEventBodyShapes.js

@@ -15,8 +15,7 @@ export const ingestResponseBodyShape = (state, requestId, value) => {
         invalidResponseBodyShape(state, requestId);
         return;
     }
-    const inferred = inferBodyShape(decoded);
-    updateResponseBodyShape(state, requestId, inferred.shape);
+    updateResponseBodyShape(state, requestId, inferJsonShape(decoded));
 };
 export const requestBodyShape = (state, request) => {
     if (!state.input.include_json_body_shapes)
@@ -24,10 +23,10 @@ export const requestBodyShape = (state, request) => {
     const body = cdpStringValue(request.postData);
     if (!isJsonContentType(recordValue(request.headers)) || body === undefined)
         return { status: "unavailable", request: null, response: null };
-    const inferred = inferBodyShape(body);
+    const shape = inferJsonShape(body);
     return {
-        status: inferred.shape === null ? "unavailable" : "included",
-        request: inferred.shape,
+        status: shape === null ? "unavailable" : "included",
+        request: shape,
         response: null,
     };
 };
@@ -46,9 +45,6 @@ export const updateResponseBodyShape = (state, requestId, response) => {
         body_shapes: { status, request, response },
     });
 };
-const inferBodyShape = (text) => {
-    return { shape: inferJsonShape(text) };
-};
 const invalidResponseBodyShape = (state, requestId) => {
     updateResponseBodyShape(state, requestId, null);
     state.completeness.exclude("json_body_shapes", "invalid_protocol_value");

package/dist/browser/CdpCaptureEventHandlers.js

@@ -1,3 +1,4 @@
+import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { safeResponseMetadata } from "./CdpSafeMetadata.js";
 import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, scriptMetadataValues, cdpStringValue, } from "./CdpCaptureValues.js";
@@ -13,6 +14,7 @@ export const handleExecutionContextCreated = (state, params) => {
         frameId === undefined)
         return;
     const key = String(identifier);
+    // New contexts may reuse an id. Scripts already parsed keep the frame stored on them.
     state.executionContextFrames.set(key, frameId);
 };
 export const handleExecutionContextDestroyed = (state, params) => {
@@ -39,6 +41,7 @@ export const handleScriptParsed = (state, params) => {
         state.completeness.exclude("scripts", exclusionReasonForUrl(rawUrl));
         return;
     }
+    const executionContext = executionContextKey(params.executionContextId);
     const baseScript = {
         scriptId,
         rawUrl,
@@ -46,7 +49,10 @@ export const handleScriptParsed = (state, params) => {
         origin: sanitized.origin,
         ...scriptMetadataValues(params),
         language: cdpStringValue(params.scriptLanguage) ?? null,
-        executionContextKey: executionContextKey(params.executionContextId),
+        executionContextKey: executionContext,
+        frameId: executionContext === null
+            ? null
+            : (state.executionContextFrames.get(executionContext) ?? null),
     };
     const baseBytes = scriptMetadataStringBytes(baseScript);
     const sourceMapDeclared = typeof params.sourceMapURL === "string" && params.sourceMapURL.length > 0;
@@ -79,7 +85,8 @@ const scriptMetadataStringBytes = (script) => stringByteLength(script.scriptId)
     stringByteLength(script.origin) +
     stringByteLength(script.hash) +
     stringByteLength(script.language) +
-    stringByteLength(script.executionContextKey);
+    stringByteLength(script.executionContextKey) +
+    stringByteLength(script.frameId);
 const stringByteLength = (value) => value === null ? 0 : Buffer.byteLength(value, "utf8");
 const sourceMapForScript = (value, scriptUrl, state, remainingBytes) => {
     const declaredUrl = cdpStringValue(value);
@@ -350,8 +357,10 @@ const captureConsoleText = (state, arguments_) => {
 };
 export const handleWebSocketFrame = (state, params, direction) => {
     const requestId = cdpStringValue(params.requestId);
-    if (requestId === undefined ||
-        (!state.network.has(requestId) && !state.allowedWebSockets.has(requestId)))
+    if (requestId === undefined)
+        return;
+    const connection = state.webSocketConnectionsById.get(requestId);
+    if (connection === undefined)
         return;
     const response = recordValue(params.response);
     const payload = cdpStringValue(response?.payloadData) ?? "";
@@ -359,11 +368,10 @@ export const handleWebSocketFrame = (state, params, direction) => {
     const decoded = opcode === 1 ? undefined : decodeBase64(payload);
     if (opcode !== 1 && decoded === undefined)
         state.completeness.exclude("websocket_frames", "invalid_protocol_value");
-    state.websockets.push({
-        request_id: requestId,
+    connection.events.push({
         direction,
         opcode,
-        payload_bytes: opcode === 1 ? Buffer.byteLength(payload) : (decoded?.byteLength ?? 0),
+        payload_bytes: opcode === 1 ? Buffer.byteLength(payload) : (decoded?.byteLength ?? null),
         payload_shape: captureWebSocketShape(state, payload, opcode),
     });
 };
@@ -389,9 +397,10 @@ export const handleWebSocketCreated = (state, params) => {
         state.completeness.exclude("websocket_connections", "invalid_protocol_value");
         return;
     }
+    const sourceUrl = sanitizeBrowserUrl(rawUrl).url;
     let parsed;
     try {
-        parsed = new URL(rawUrl);
+        parsed = new URL(sourceUrl);
     }
     catch (cause) {
         // Unparseable URLs are recorded as unsupported, not as failures.
@@ -411,7 +420,15 @@ export const handleWebSocketCreated = (state, params) => {
         state.completeness.exclude("websocket_connections", "disallowed_origin");
         return;
     }
-    state.allowedWebSockets.add(requestId);
+    if (state.webSocketConnectionsById.has(requestId)) {
+        state.completeness.exclude("websocket_connections", "invalid_protocol_value");
+        return;
+    }
+    state.webSocketConnectionsById.set(requestId, {
+        request_id: requestId,
+        url: sourceUrl,
+        events: [],
+    });
 };
 export const handleFrameNavigated = (state, params) => {
     const frame = recordValue(params.frame);

package/dist/browser/CdpCaptureEvents.js

@@ -16,9 +16,8 @@ export class CdpCaptureEvents {
     network = new Map();
     networkRequestTimestamps = new Map();
     malformedRedirectRequestIds = new Set();
-    allowedWebSockets = new Set();
+    webSocketConnectionsById = new Map();
     console = [];
-    websockets = [];
     responseMetadata = [];
     agentHints = [];
     completeness = new CdpCaptureCompleteness([
@@ -54,9 +53,8 @@ export class CdpCaptureEvents {
         this.network.clear();
         this.networkRequestTimestamps.clear();
         this.malformedRedirectRequestIds.clear();
-        this.allowedWebSockets.clear();
+        this.webSocketConnectionsById.clear();
         this.console.length = 0;
-        this.websockets.length = 0;
         this.responseMetadata.length = 0;
         this.agentHints.length = 0;
         this.completeness.reset();
@@ -136,11 +134,8 @@ export class CdpCaptureEvents {
     }
     /** Resolve a transient execution context to one already authorized frame. */
     frameForScript(script, allowedFrameIds) {
-        if (script.executionContextKey === null)
-            return null;
-        const frameId = this.executionContextFrames.get(script.executionContextKey);
-        return frameId !== undefined && allowedFrameIds.has(frameId)
-            ? frameId
+        return script.frameId !== null && allowedFrameIds.has(script.frameId)
+            ? script.frameId
             : null;
     }
     responseBodyRequestIds() {

package/dist/browser/CdpConnection.js

@@ -5,6 +5,10 @@ import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { CdpCommandRejection } from "./CdpCommandRejection.js";
 import {} from "../domain/browserObservationErrors.js";
 import { safeParseJson } from "../domain/safeJson.js";
+import { WEB_RUNTIME_LIMITS } from "../domain/webRuntime.js";
+// ws currently stores maxPayload as a signed 32-bit integer. Larger values can
+// wrap to a negative number, which disables its limit check.
+const MAX_WEBSOCKET_PAYLOAD_BYTES = 0x7fff_ffff;
 /** Correlated JSON-RPC transport for one CDP target operation. */
 export class CdpConnection {
     socket;
@@ -16,6 +20,7 @@ export class CdpConnection {
     #protocolFailureListeners = new Set();
     #nextId = 1;
     #closed = false;
+    #closePromise;
     #protocolFailed = false;
     #transportFailure = "disconnected";
     constructor(socket, operation, maxPayloadBytes) {
@@ -32,13 +37,20 @@ export class CdpConnection {
     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: limits?.maxPayloadBytes ?? 0,
+            maxPayload: maxPayloadBytes,
             perMessageDeflate: false,
         });
         await waitForOpen(socket, operation, signal);
-        return new CdpConnection(socket, operation, limits?.maxPayloadBytes ?? 0);
+        return new CdpConnection(socket, operation, maxPayloadBytes);
     }
     /** Subscribe to validated CDP event envelopes. */
     onEvent(listener) {
@@ -109,9 +121,14 @@ export class CdpConnection {
         });
     }
     /** Close only REA's socket; never close the browser or selected page. */
-    async close() {
-        if (this.#closed)
-            return;
+    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)

package/dist/browser/CdpPageCapture.js

@@ -188,7 +188,7 @@ const normalizedInspection = (state, captured) => ({
     resources: [...captured.resources],
     network: {
         requests: [...state.events.network.values()],
-        websocket_events: [...state.events.websockets],
+        websocket_connections: [...state.events.webSocketConnectionsById.values()],
         coverage_started_at: state.startedAt,
         prior_activity_available: false,
     },

package/dist/browser/CdpTargetSession.js

@@ -20,43 +20,39 @@ export const openCdpTargetSession = async (discovery, target, operation, signal,
 /** Disable enabled domains, detach browser sessions, and close REA's socket. */
 export const closeCdpTargetSession = async (targetSession, enabledDomains, signal) => {
     const { connection, sessionId } = targetSession;
-    for (const [index, domain] of enabledDomains.entries()) {
-        if (signal?.aborted === true) {
-            await closeCancelledTargetSession(targetSession, enabledDomains.slice(index));
-            return;
-        }
-        try {
-            await connection.send(`${domain}.disable`, {}, sessionId, signal);
-        }
-        catch (cause) {
-            // best-effort cleanup: domain disable continues to detach/close boundary.
-            void cause;
-        }
-    }
-    if (signal?.aborted === true) {
-        await closeCancelledTargetSession(targetSession, []);
-        return;
-    }
-    if (sessionId !== undefined)
-        try {
-            await connection.send("Target.detachFromTarget", { sessionId }, undefined, signal);
-        }
-        catch (cause) {
-            // best-effort cleanup: closing REA's socket is the final cleanup boundary.
-            void cause;
-        }
-    await connection.close();
-};
-const closeCancelledTargetSession = async ({ connection, sessionId }, enabledDomains) => {
-    const commands = enabledDomains.map((domain) => connection.send(`${domain}.disable`, {}, sessionId));
-    if (sessionId !== undefined)
-        commands.push(connection.send("Target.detachFromTarget", { sessionId }));
-    const settled = Promise.allSettled(commands);
+    const cleanup = new AbortController();
+    const domainSignal = signal === undefined
+        ? cleanup.signal
+        : AbortSignal.any([cleanup.signal, signal]);
+    const timeout = setTimeout(() => cleanup.abort(), 1_000);
+    timeout.unref();
     try {
-        await connection.close();
+        if (signal?.aborted !== true) {
+            for (const domain of enabledDomains) {
+                if (domainSignal.aborted)
+                    break;
+                try {
+                    await connection.send(`${domain}.disable`, {}, sessionId, domainSignal);
+                }
+                catch {
+                    // Best-effort domain cleanup; transport close is the definitive boundary.
+                }
+            }
+        }
+        // Cancellation skips optional domain shutdown but still releases the
+        // attached session using its independent, bounded cleanup signal.
+        if (!cleanup.signal.aborted && sessionId !== undefined)
+            try {
+                await connection.send("Target.detachFromTarget", { sessionId }, undefined, cleanup.signal);
+            }
+            catch {
+                // Best-effort detach; transport close is the definitive boundary.
+            }
     }
     finally {
-        await settled;
+        clearTimeout(timeout);
+        cleanup.abort();
+        await connection.close();
     }
 };
 const attachedSessionId = (value, operation) => {