@reticlehq/browser 3.8.0 → 3.8.2

package/dist/dom/visibility.js

@@ -0,0 +1,322 @@
+import { isHtmlElement } from './realm.js';
+import { parentAcrossShadowBoundary } from './shadow-registry.js';
+import { clippingBox, overflowAxes, scrolledInto, } from './paint-context.js';
+export const HTML_DETAILS_TAG = 'details';
+export const HTML_DETAILS_OPEN_ATTRIBUTE = 'open';
+export const HTML_SUMMARY_TAG = 'summary';
+function hiddenInsideClosedDetails(el) {
+    const parent = el.parentElement;
+    if (null === parent) {
+        return false;
+    }
+    const details = parent.closest(HTML_DETAILS_TAG);
+    if (null === details || details.hasAttribute(HTML_DETAILS_OPEN_ATTRIBUTE)) {
+        return false;
+    }
+    const summary = Array.from(details.children).find((child) => HTML_SUMMARY_TAG === child.localName);
+    return summary === undefined || !summary.contains(el);
+}
+function stalledFade(el) {
+    if (!el.ownerDocument.hidden || !('getAnimations' in el)) {
+        return false;
+    }
+    return el.getAnimations().some((a) => 'running' === a.playState || a.pending);
+}
+const OVERLAY_ARIA_HIDDEN = 'data-aria-hidden';
+function hiddenByAnOverlay(el) {
+    return el.hasAttribute(OVERLAY_ARIA_HIDDEN);
+}
+function selfCssHidden(el, style) {
+    if (isHtmlElement(el) && el.hidden) {
+        return true;
+    }
+    if (hiddenInsideClosedDetails(el)) {
+        return true;
+    }
+    if (style !== null) {
+        if ('none' === style.display ||
+            'hidden' === style.visibility ||
+            'collapse' === style.visibility) {
+            return true;
+        }
+        if (0 === Number.parseFloat(style.opacity || '1') && !stalledFade(el)) {
+            return true;
+        }
+        if (clippedAway(style)) {
+            return true;
+        }
+    }
+    return false;
+}
+function clippedAway(style) {
+    const rect = /^rect\((.*)\)$/.exec(style.getPropertyValue('clip').trim());
+    if (null !== rect && ('absolute' === style.position || 'fixed' === style.position)) {
+        const [top, right, bottom, left] = (rect[1] ?? '').split(/[\s,]+/).map(Number.parseFloat);
+        if (right !== undefined && left !== undefined && right <= left) {
+            return true;
+        }
+        if (bottom !== undefined && top !== undefined && bottom <= top) {
+            return true;
+        }
+    }
+    const inset = /^inset\(([^)]*)\)$/.exec(style.getPropertyValue('clip-path').trim());
+    const edges = inset?.[1]
+        ?.split(/\s+round\s/)[0]
+        ?.trim()
+        .split(/\s+/) ?? [];
+    const known = (edge) => edge.endsWith('%') || 0 === Number.parseFloat(edge);
+    if (0 === edges.length || !edges.every(known)) {
+        return false;
+    }
+    const [top = 0, right = top, bottom = top, left = right] = edges.map(Number.parseFloat);
+    return top + bottom >= 100 || left + right >= 100;
+}
+function selfHidden(el, style) {
+    if ('true' === el.getAttribute('aria-hidden') && !hiddenByAnOverlay(el)) {
+        return true;
+    }
+    return selfCssHidden(el, style);
+}
+export function isHiddenByAriaOnly(el) {
+    let foundAriaHidden = false;
+    let current = el;
+    while (null !== current) {
+        if ('true' === current.getAttribute('aria-hidden')) {
+            foundAriaHidden = true;
+        }
+        const style = current.ownerDocument.defaultView?.getComputedStyle(current) ?? null;
+        if (selfCssHidden(current, style)) {
+            return false;
+        }
+        current = parentAcrossShadowBoundary(current);
+    }
+    return foundAriaHidden;
+}
+export function isRenderedOutsideAriaHidden(el) {
+    let current = el;
+    while (null !== current) {
+        if ('true' === current.getAttribute('aria-hidden')) {
+            return false;
+        }
+        const style = current.ownerDocument.defaultView?.getComputedStyle(current) ?? null;
+        if (selfCssHidden(current, style)) {
+            return false;
+        }
+        current = parentAcrossShadowBoundary(current);
+    }
+    return true;
+}
+const CLIPPING_OVERFLOW = new Set(['hidden', 'clip']);
+const SCROLLING_OVERFLOW = new Set(['auto', 'scroll']);
+const NON_CLIPPING_DISPLAY = new Set([
+    'contents',
+    'table-row',
+    'table-row-group',
+    'table-header-group',
+    'table-footer-group',
+    'table-column',
+    'table-column-group',
+]);
+const TRANSFORM_CONTAINING_BLOCK_PROPERTIES = new Set([
+    'transform',
+    'translate',
+    'rotate',
+    'scale',
+    'perspective',
+]);
+const CONTAINING_BLOCK_PROPERTIES = new Set([
+    ...TRANSFORM_CONTAINING_BLOCK_PROPERTIES,
+    'filter',
+    'backdrop-filter',
+]);
+const CONTAINING_BLOCK_CONTAIN = new Set(['layout', 'paint', 'strict', 'content']);
+const REPLACED_INLINE_TAGS = new Set([
+    'img',
+    'video',
+    'audio',
+    'canvas',
+    'iframe',
+    'embed',
+    'object',
+    'input',
+    'textarea',
+    'select',
+]);
+const visibilityInfoMemos = new WeakMap();
+function visibilityInfoMemo(memo) {
+    if (memo === undefined) {
+        return new Map();
+    }
+    let info = visibilityInfoMemos.get(memo);
+    if (info === undefined) {
+        info = new Map();
+        visibilityInfoMemos.set(memo, info);
+    }
+    return info;
+}
+function ownVisibilityInfo(el, memo) {
+    let info = memo.get(el);
+    if (info === undefined) {
+        const style = el.ownerDocument.defaultView?.getComputedStyle(el) ?? null;
+        if (selfHidden(el, style)) {
+            info = {
+                hidden: true,
+                style,
+                parent: null,
+                clipX: false,
+                clipY: false,
+                scrollX: false,
+                scrollY: false,
+                hasClipping: false,
+            };
+            memo.set(el, info);
+            return info;
+        }
+        const parent = parentAcrossShadowBoundary(el);
+        const inherited = null === parent ? undefined : ownVisibilityInfo(parent, memo);
+        const [overflowX, overflowY] = overflowAxes(style);
+        const root = el.ownerDocument.documentElement;
+        const viewportOverflow = el === root ||
+            (el === el.ownerDocument.body &&
+                overflowAxes(ownVisibilityInfo(root, memo).style).every((axis) => 'visible' === axis));
+        const hasClipBox = !viewportOverflow &&
+            !NON_CLIPPING_DISPLAY.has(style?.display ?? '') &&
+            !(isHtmlElement(el) && 'inline' === style?.display);
+        const clipX = hasClipBox && CLIPPING_OVERFLOW.has(overflowX);
+        const clipY = hasClipBox && CLIPPING_OVERFLOW.has(overflowY);
+        info = {
+            hidden: true === inherited?.hidden,
+            style,
+            parent,
+            clipX,
+            clipY,
+            scrollX: hasClipBox && SCROLLING_OVERFLOW.has(overflowX),
+            scrollY: hasClipBox && SCROLLING_OVERFLOW.has(overflowY),
+            hasClipping: clipX || clipY || true === inherited?.hasClipping,
+        };
+        memo.set(el, info);
+    }
+    return info;
+}
+function positionedContainingBlock(el, fixed, memo) {
+    for (let parent = ownVisibilityInfo(el, memo).parent; parent !== null; parent = ownVisibilityInfo(parent, memo).parent) {
+        const style = ownVisibilityInfo(parent, memo).style;
+        if (null === style || 'contents' === style.display) {
+            continue;
+        }
+        if (!fixed && '' !== style.position && 'static' !== style.position) {
+            return parent;
+        }
+        const transformable = !('inline' === style.display &&
+            isHtmlElement(parent) &&
+            !REPLACED_INLINE_TAGS.has(parent.localName)) &&
+            'table-column' !== style.display &&
+            'table-column-group' !== style.display;
+        const applies = (property) => transformable || !TRANSFORM_CONTAINING_BLOCK_PROPERTIES.has(property);
+        if ([...CONTAINING_BLOCK_PROPERTIES].some((property) => {
+            const value = style.getPropertyValue(property);
+            return applies(property) && '' !== value && 'none' !== value;
+        }) ||
+            style.willChange
+                .split(',')
+                .some((property) => CONTAINING_BLOCK_PROPERTIES.has(property.trim()) && applies(property.trim())) ||
+            (transformable &&
+                !NON_CLIPPING_DISPLAY.has(style.display) &&
+                (style.contain.split(/\s+/).some((value) => CONTAINING_BLOCK_CONTAIN.has(value)) ||
+                    'auto' === style.contentVisibility))) {
+            return parent;
+        }
+    }
+    return null;
+}
+function visibleBounds(el, memo, initial, throughScrollers = false) {
+    let bounds = initial;
+    const target = ownVisibilityInfo(el, memo);
+    if (target.hidden) {
+        return null;
+    }
+    if (null === target.parent || !ownVisibilityInfo(target.parent, memo).hasClipping) {
+        return bounds;
+    }
+    let clipFrom;
+    for (let current = el; current !== null; current = ownVisibilityInfo(current, memo).parent) {
+        const info = ownVisibilityInfo(current, memo);
+        if (info.hidden) {
+            return null;
+        }
+        if (current === clipFrom) {
+            clipFrom = undefined;
+        }
+        const style = info.style;
+        if (throughScrollers &&
+            current !== el &&
+            undefined === clipFrom &&
+            (info.scrollX || info.scrollY)) {
+            bounds ??= el.getBoundingClientRect();
+            if (bounds.width > 0 && bounds.height > 0) {
+                bounds = scrolledInto(bounds, clippingBox(current, info), info.scrollX, info.scrollY);
+            }
+        }
+        if (current !== el && undefined === clipFrom && (info.clipX || info.clipY)) {
+            bounds ??= el.getBoundingClientRect();
+            if (bounds.width > 0 && bounds.height > 0) {
+                const clip = clippingBox(current, info);
+                const left = info.clipX ? Math.max(bounds.left, clip.left) : bounds.left;
+                const right = info.clipX ? Math.min(bounds.right, clip.right) : bounds.right;
+                const top = info.clipY ? Math.max(bounds.top, clip.top) : bounds.top;
+                const bottom = info.clipY ? Math.min(bounds.bottom, clip.bottom) : bounds.bottom;
+                if (right <= left || bottom <= top) {
+                    return null;
+                }
+                bounds = { left, right, top, bottom, width: right - left, height: bottom - top };
+            }
+        }
+        if (clipFrom === undefined && ('absolute' === style?.position || 'fixed' === style?.position)) {
+            clipFrom = positionedContainingBlock(current, 'fixed' === style?.position, memo);
+        }
+    }
+    return bounds;
+}
+export function isInViewport(el, memo) {
+    if (!isVisible(el, memo)) {
+        return false;
+    }
+    const view = el.ownerDocument.defaultView;
+    if (null === view) {
+        return false;
+    }
+    const r = visibleBounds(el, visibilityInfoMemo(memo), el.getBoundingClientRect());
+    if (null === r || undefined === r) {
+        return false;
+    }
+    if (r.width <= 0 || r.height <= 0) {
+        return false;
+    }
+    return r.bottom > 0 && r.right > 0 && r.top < view.innerHeight && r.left < view.innerWidth;
+}
+function collapsed(el, memo) {
+    const own = ownVisibilityInfo(el, memo);
+    if (!own.clipX && !own.clipY) {
+        return false;
+    }
+    const rects = Array.from(el.getClientRects());
+    return (rects.length > 0 &&
+        rects.every((r) => (own.clipX && 0 === r.width) ||
+            (own.clipY && 0 === r.height) ||
+            (own.clipX && own.clipY && r.width <= 1 && r.height <= 1)));
+}
+export function isVisible(el, memo) {
+    if (!el.isConnected) {
+        return false;
+    }
+    const cached = memo?.get(el);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const info = visibilityInfoMemo(memo);
+    const result = visibleBounds(el, info, undefined, true) !== null && !collapsed(el, info);
+    if (memo !== undefined) {
+        memo.set(el, result);
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -21,7 +21,8 @@ export { inspectChart, canvasChartData } from './dom/chart.js';
 export type { ChartReport, ChartFinding, CanvasChartData, ChartGlobals } from './dom/chart.js';
 export { matchQuery, runQuery } from './dom/query.js';
 export { executeAction, executeSequence } from './actions/actions.js';
-export { describe, getRole, getAccessibleName, getStates, isVisible } from './dom/a11y.js';
+export { describe, getRole, getAccessibleName, getStates } from './dom/a11y.js';
+export { isVisible } from './dom/visibility.js';
 export { refs, RefRegistry } from './dom/addressing/refs.js';
 export { Annotator, installAnnotator, type AnnotatorDeps } from './review/annotator.js';
 export { resolveMarkAnchor, type MarkAnchor } from './review/mark-anchor.js';

package/dist/index.js

@@ -15,7 +15,8 @@ export { buildSnapshot } from './dom/snapshot.js';
 export { inspectChart, canvasChartData } from './dom/chart.js';
 export { matchQuery, runQuery } from './dom/query.js';
 export { executeAction, executeSequence } from './actions/actions.js';
-export { describe, getRole, getAccessibleName, getStates, isVisible } from './dom/a11y.js';
+export { describe, getRole, getAccessibleName, getStates } from './dom/a11y.js';
+export { isVisible } from './dom/visibility.js';
 export { refs, RefRegistry } from './dom/addressing/refs.js';
 export { Annotator, installAnnotator } from './review/annotator.js';
 export { resolveMarkAnchor } from './review/mark-anchor.js';

package/dist/observers/dom.js

@@ -1,6 +1,7 @@
 import { readTestId, testIdSelector } from '../dom/addressing/testid-attr.js';
 import { EventType, REDACTED_VALUE, TruncationChannel } from '@reticlehq/core';
-import { getAccessibleName, getRole, isSensitiveField, isVisible } from '../dom/a11y.js';
+import { getAccessibleName, getRole, isSensitiveField } from '../dom/a11y.js';
+import { isVisible } from '../dom/visibility.js';
 import { refs } from '../dom/addressing/refs.js';
 function regionKeyOf(target) {
     const el = isElement(target) ? target : null;

package/dist/observers/net-detail/network-body.js

@@ -1,12 +1,14 @@
 import { REDACTED_VALUE, ResponseBodyReason } from '@reticlehq/core';
 import { isSensitiveKey, safeStringify, scrubKnownSecrets } from '../../security/serialization.js';
 import { nativeClearTimeout, nativeSetTimeout } from '../../timers/native/native-timers.js';
+import { isEventStream, redactEventStream } from './network-event-stream.js';
 const CAPTURABLE_CONTENT = /application\/json|text\/|application\/xml|x-www-form-urlencoded|graphql/i;
 const STREAMING_CONTENT = /event-stream|x-ndjson|application\/stream/i;
 const ENDLESS_BY_DESIGN = /event-stream/i;
 export function isStreamingBody(contentType, contentLength) {
-    if (contentType !== null && ENDLESS_BY_DESIGN.test(contentType))
+    if (contentType !== null && ENDLESS_BY_DESIGN.test(contentType)) {
         return false;
+    }
     return null === contentLength;
 }
 const BODY_READ_TIMEOUT_MS = 500;
@@ -21,22 +23,26 @@ export async function withBodyDeadline(read) {
         ]);
     }
     finally {
-        if (timer !== undefined)
+        if (timer !== undefined) {
             nativeClearTimeout(timer);
+        }
     }
 }
 export function skippedBodyReason(contentType) {
-    if (null === contentType)
+    if (null === contentType) {
         return undefined;
+    }
     return STREAMING_CONTENT.test(contentType)
         ? ResponseBodyReason.STREAMING
         : ResponseBodyReason.NOT_TEXT;
 }
 export function isCapturableType(contentType) {
-    if (null === contentType)
+    if (null === contentType) {
         return false;
-    if (STREAMING_CONTENT.test(contentType))
+    }
+    if (STREAMING_CONTENT.test(contentType)) {
         return false;
+    }
     return CAPTURABLE_CONTENT.test(contentType);
 }
 const DEFAULT_BODY_CHARS = 8192;
@@ -44,8 +50,9 @@ const MAX_CONFIGURABLE_BODY_CHARS = 262144;
 const MIN_CONFIGURABLE_BODY_CHARS = 256;
 let bodyMaxChars = DEFAULT_BODY_CHARS;
 export function setNetworkBodyMaxChars(chars) {
-    if (!Number.isFinite(chars))
+    if (!Number.isFinite(chars)) {
         return;
+    }
     bodyMaxChars = Math.min(MAX_CONFIGURABLE_BODY_CHARS, Math.max(MIN_CONFIGURABLE_BODY_CHARS, Math.floor(chars)));
 }
 export function networkBodyMaxChars() {
@@ -60,7 +67,13 @@ const AUTH_SCHEME_TOKEN = /\b(Bearer|Basic)\s+(?=[A-Za-z0-9._~+/=-]{16,})(?=[A-Z
 function redactText(text) {
     return (text
         .replace(AUTH_SCHEME_TOKEN, (_m, scheme) => `${scheme} ${REDACTED_VALUE}`)
-        .replace(/([A-Za-z0-9_.-]+)(\s*[=:]\s*"?)([^&\s,;"}]+)/g, (match, key, sep) => isSensitiveKey(key) ? `${key}${sep}${REDACTED_VALUE}` : match));
+        .replace(/([A-Za-z0-9_.-]+)("?\s*[=:]\s*)("(?:\\.|[^"\\])*"?|[^&\s,;"}]+)/g, (match, key, sep, value) => {
+        if (!isSensitiveKey(key)) {
+            return match;
+        }
+        const redacted = value.startsWith('"') ? `"${REDACTED_VALUE}"` : REDACTED_VALUE;
+        return `${key}${sep}${redacted}`;
+    }));
 }
 const ERROR_BODY_CHARS = 4096;
 export function shouldCaptureErrorBody(status, enabled) {
@@ -68,8 +81,9 @@ export function shouldCaptureErrorBody(status, enabled) {
 }
 export function projectErrorBody(rawText, contentType) {
     const projected = projectBody(rawText, contentType);
-    if (projected.body.length <= ERROR_BODY_CHARS)
+    if (projected.body.length <= ERROR_BODY_CHARS) {
         return projected;
+    }
     return { body: projected.body.slice(0, ERROR_BODY_CHARS), truncated: true };
 }
 export function projectBody(rawText, contentType) {
@@ -77,6 +91,7 @@ export function projectBody(rawText, contentType) {
     const scanChars = scanWidth(!isJson);
     const oversized = rawText.length > scanChars;
     const text = oversized ? rawText.slice(0, scanChars) : rawText;
+    let incomplete = false;
     let out;
     if (isJson) {
         try {
@@ -86,10 +101,15 @@ export function projectBody(rawText, contentType) {
             out = redactText(text);
         }
     }
+    else if (isEventStream(contentType)) {
+        const projected = redactEventStream(text);
+        out = redactText(projected.body);
+        incomplete = projected.truncated;
+    }
     else {
         out = redactText(text);
     }
     out = scrubKnownSecrets(out);
-    const truncated = oversized || out.length > bodyMaxChars;
+    const truncated = incomplete || oversized || out.length > bodyMaxChars;
     return { body: out.length > bodyMaxChars ? out.slice(0, bodyMaxChars) : out, truncated };
 }

package/dist/observers/net-detail/network-event-stream.d.ts

@@ -0,0 +1,5 @@
+export declare function isEventStream(contentType: string | null): boolean;
+export declare function redactEventStream(text: string): {
+    body: string;
+    truncated: boolean;
+};

package/dist/observers/net-detail/network-event-stream.js

@@ -0,0 +1,55 @@
+import { REDACTED_VALUE } from '@reticlehq/core';
+import { sanitizeWithReport } from '../../security/serialization.js';
+const EVENT_STREAM_CONTENT = /^text\/event-stream(?:\s*;|\s*$)/i;
+const DATA_FIELD = 'data:';
+const DATA_NAME = 'data';
+const JSON_CONTAINER = /^[{[]/;
+const TEXT_MARKER = /^\[[A-Z_]+\]$/;
+export function isEventStream(contentType) {
+    return contentType !== null && EVENT_STREAM_CONTENT.test(contentType);
+}
+function isData(line) {
+    return DATA_NAME === line || line.startsWith(DATA_FIELD);
+}
+export function redactEventStream(text) {
+    let truncated = false;
+    const records = text.replace(/\r\n?/g, '\n').split('\n\n');
+    const body = records
+        .map((record) => {
+        const lines = record.split('\n');
+        const data = lines
+            .filter(isData)
+            .map((line) => line.slice(DATA_FIELD.length).replace(/^ /, ''))
+            .join('\n');
+        if (!JSON_CONTAINER.test(data.trimStart()) || TEXT_MARKER.test(data.trim())) {
+            return record;
+        }
+        let projected;
+        try {
+            const sanitized = sanitizeWithReport(JSON.parse(data));
+            projected = JSON.stringify(sanitized.value);
+            if (sanitized.truncation !== undefined) {
+                truncated = true;
+            }
+        }
+        catch {
+            projected = REDACTED_VALUE;
+            truncated = true;
+        }
+        let first = true;
+        return lines
+            .flatMap((line) => {
+            if (!isData(line)) {
+                return [line];
+            }
+            if (!first) {
+                return [];
+            }
+            first = false;
+            return [`${DATA_FIELD} ${projected}`];
+        })
+            .join('\n');
+    })
+        .join('\n\n');
+    return { body, truncated };
+}

package/dist/observers/net-detail/network-frames.d.ts

@@ -0,0 +1,2 @@
+export declare function frameFields(data: unknown, captureBodies: boolean): Record<string, unknown>;
+export declare function isBridgeSocket(url: string): boolean;

package/dist/observers/net-detail/network-frames.js

@@ -0,0 +1,39 @@
+import { RETICLE_WS_PATH } from '@reticlehq/core';
+import { projectBody } from './network-body.js';
+function binaryFrameBytes(data) {
+    if (data instanceof ArrayBuffer) {
+        return data.byteLength;
+    }
+    if (typeof Blob !== 'undefined' && data instanceof Blob) {
+        return data.size;
+    }
+    if (ArrayBuffer.isView(data)) {
+        return data.byteLength;
+    }
+    return undefined;
+}
+export function frameFields(data, captureBodies) {
+    if (typeof data !== 'string') {
+        const bytes = binaryFrameBytes(data);
+        return bytes === undefined
+            ? { frameType: typeof data }
+            : { frameType: 'binary', frameBytes: bytes };
+    }
+    const out = { frameBytes: data.length };
+    if (captureBodies) {
+        const { body, truncated } = projectBody(data, 'application/json');
+        out['frame'] = body;
+        if (truncated) {
+            out['frameTruncated'] = true;
+        }
+    }
+    return out;
+}
+export function isBridgeSocket(url) {
+    try {
+        return new URL(url, location.href).pathname === RETICLE_WS_PATH;
+    }
+    catch {
+        return url.includes(RETICLE_WS_PATH);
+    }
+}

package/dist/observers/net-detail/network-response-body.d.ts

@@ -0,0 +1,3 @@
+import { isEventStream } from './network-event-stream.js';
+export { isEventStream };
+export declare function captureResponseBody(response: Response, contentType: string | null, captureBodies: boolean, signal: AbortSignal): Promise<Record<string, unknown>>;

package/dist/observers/net-detail/network-response-body.js

@@ -0,0 +1,97 @@
+import { ResponseBodyReason } from '@reticlehq/core';
+import { nativeClearTimeout, nativeSetTimeout } from '../../timers/native/native-timers.js';
+import { networkBodyMaxChars, projectBody, projectErrorBody, withBodyDeadline, } from './network-body.js';
+import { isEventStream } from './network-event-stream.js';
+export { isEventStream };
+const EVENT_STREAM_READ_MS = 10_000;
+const UTF8_MAX_BYTES_PER_CHAR = 4;
+const REDACTION_LOOKAHEAD = 2;
+async function readEventStream(clone, signal) {
+    if (signal.aborted || typeof clone.body?.getReader !== 'function') {
+        return undefined;
+    }
+    const reader = clone.body.getReader();
+    const decoder = new TextDecoder();
+    const limit = networkBodyMaxChars() * REDACTION_LOOKAHEAD;
+    let text = '';
+    let complete = false;
+    let stopped = false;
+    let stop = () => undefined;
+    const interrupted = new Promise((resolve) => {
+        stop = () => {
+            stopped = true;
+            resolve();
+        };
+    });
+    const timer = nativeSetTimeout(stop, EVENT_STREAM_READ_MS);
+    signal.addEventListener('abort', stop, { once: true });
+    try {
+        await Promise.race([
+            (async () => {
+                while (!stopped && !signal.aborted) {
+                    const next = await reader.read();
+                    if (stopped || signal.aborted) {
+                        return;
+                    }
+                    if (next.done) {
+                        text += decoder.decode();
+                        complete = true;
+                        return;
+                    }
+                    const remaining = limit - text.length;
+                    const bytes = next.value.subarray(0, remaining * UTF8_MAX_BYTES_PER_CHAR);
+                    const decoded = decoder.decode(bytes, { stream: true });
+                    text += decoded.slice(0, remaining);
+                    if (text.length >= limit || bytes.byteLength < next.value.byteLength) {
+                        return;
+                    }
+                }
+            })(),
+            interrupted,
+        ]);
+    }
+    catch {
+    }
+    finally {
+        nativeClearTimeout(timer);
+        signal.removeEventListener('abort', stop);
+        if (!complete) {
+            void reader.cancel().catch(() => undefined);
+        }
+        reader.releaseLock();
+    }
+    return !complete && 0 === text.length ? undefined : { text, complete };
+}
+export async function captureResponseBody(response, contentType, captureBodies, signal) {
+    const unreadable = captureBodies ? { responseBodyReason: ResponseBodyReason.UNREADABLE } : {};
+    if (isEventStream(contentType) && (!captureBodies || signal.aborted)) {
+        return unreadable;
+    }
+    try {
+        const clone = response.clone();
+        let text;
+        let incomplete = false;
+        if (isEventStream(contentType)) {
+            const stream = await readEventStream(clone, signal);
+            text = stream?.text;
+            incomplete = false === stream?.complete;
+        }
+        else {
+            text = await withBodyDeadline(clone.text());
+        }
+        if (undefined === text) {
+            return unreadable;
+        }
+        const projected = captureBodies
+            ? projectBody(text, contentType)
+            : projectErrorBody(text, contentType);
+        return {
+            responseBody: projected.body,
+            ...(incomplete || projected.truncated ? { responseBodyTruncated: true } : {}),
+            ...(captureBodies ? {} : { responseBodyReason: ResponseBodyReason.ERROR_STATUS }),
+        };
+    }
+    catch {
+        return unreadable;
+    }
+}