@reticlehq/browser 2.13.1 → 3.1.0

package/dist/observers/frames.d.ts

@@ -1,12 +1,3 @@
 import type { Teardown } from './types.js';
-/** Every same-origin frame body at or beneath `root`, in document order. */
 export declare function sameOriginFrameBodies(root: ParentNode): HTMLElement[];
-/**
- * Call `attach` for every same-origin frame body now and after each frame load.
- *
- * A frame that navigates gets a BRAND NEW document, so the old observation is dead and re-attaching on
- * `load` is not optional — without it, observation silently stops the first time an embedded panel
- * routes. Attaching twice to the same node is harmless (MutationObserver de-duplicates), so no
- * bookkeeping is kept.
- */
 export declare function observeSameOriginFrames(attach: (body: HTMLElement) => void): Teardown;

package/dist/observers/frames.js

@@ -1,30 +1,12 @@
-/**
- * Same-origin `<iframe>` documents, wired into the top document's observation.
- *
- * A `MutationObserver` is scoped to the node it is given, and a frame's document is a DIFFERENT node
- * tree — so a click inside an embedded panel changed its text and `observe` reported an empty window.
- * Measured on a console with an embedded SLA panel: the click landed, the panel updated, and the
- * observe window held zero DOM events. That is the false-green shape exactly — "nothing happened" is
- * what an agent concludes, and it is wrong.
- *
- * A MutationObserver CAN observe a node in another same-origin document, so the fix is to hand it the
- * frame bodies. Cross-origin frames stay unreachable and keep their existing blind-spot declaration.
- *
- * Network is NOT covered here. A frame's `fetch` lives in the frame's own realm and the top realm's
- * patch never sees it, so requests it makes are invisible — declared as a blind spot rather than
- * partially instrumented, because a half-seen request channel is worse than an admitted one.
- */
-/** Frames-inside-frames, bounded. Real embeds nest once, occasionally twice. */
 const DEPTH_MAX = 3;
 function bodyOf(frame) {
     try {
         return frame.contentDocument?.body ?? null;
     }
     catch {
-        return null; // cross-origin — not ours to read
+        return null;
     }
 }
-/** Every same-origin frame body at or beneath `root`, in document order. */
 export function sameOriginFrameBodies(root) {
     const found = [];
     const walk = (node, depth) => {
@@ -41,21 +23,12 @@ export function sameOriginFrameBodies(root) {
     walk(root, 0);
     return found;
 }
-/**
- * Call `attach` for every same-origin frame body now and after each frame load.
- *
- * A frame that navigates gets a BRAND NEW document, so the old observation is dead and re-attaching on
- * `load` is not optional — without it, observation silently stops the first time an embedded panel
- * routes. Attaching twice to the same node is harmless (MutationObserver de-duplicates), so no
- * bookkeeping is kept.
- */
 export function observeSameOriginFrames(attach) {
     const attachAll = () => {
         for (const body of sameOriginFrameBodies(document))
             attach(body);
     };
     attachAll();
-    // `load` does not bubble, but it DOES reach a capturing listener on the document.
     const onLoad = (event) => {
         if (event.target instanceof HTMLIFrameElement)
             attachAll();

package/dist/observers/health.d.ts

@@ -1,7 +1,2 @@
 import type { Emit, Teardown } from './types.js';
-/**
- * Report page visibility/focus immediately on change + a lightweight native heartbeat.
- * Lets the bridge know whether the tab is foregrounded so the agent never drives a throttled
- * tab blind. Uses a native (pre-bound) timer so a frozen app clock (reticle_clock) never stalls it.
- */
 export declare function installHealth(emit: Emit): Teardown;

package/dist/observers/health.js

@@ -1,11 +1,5 @@
 import { BrowserBrand, EventType, HealthReason, RETICLE_IPC_GLOBAL, SESSION_HEALTH, } from '@reticlehq/core';
-import { nativeSetInterval } from '../timers/native-timers.js';
-/**
- * Which shell this page runs in. Reported with health because it is what makes a timeout
- * diagnosable: an occluded WKWebView is SUSPENDED by macOS, so the session stays connected while
- * every command times out — and a URL cannot tell a Tauri dev server from a plain localhost app, so
- * the runtime has to come from the page itself.
- */
+import { nativeSetInterval } from '../timers/native/native-timers.js';
 function detectRuntime() {
     const w = window;
     if (w['__TAURI_INTERNALS__'] !== undefined || w['__TAURI__'] !== undefined)
@@ -14,11 +8,6 @@ function detectRuntime() {
         return 'electron';
     return 'web';
 }
-/**
- * The rendering engine, coarse on purpose. Three buckets — never the UA string itself, which is
- * high-cardinality and semi-identifying. Order matters: every Chromium UA also contains "Safari", and
- * Gecko is the only engine that reports a real `Gecko/` build token.
- */
 function detectEngine() {
     const ua = navigator.userAgent;
     if (/Chrome|Chromium|Edg\//.test(ua))
@@ -27,11 +16,6 @@ function detectEngine() {
         return 'gecko';
     return 'webkit';
 }
-/**
- * Brand names as the Chromium family and the UA string spell them, mapped to our closed vocabulary.
- * Matched on the WHOLE lowercased name, never a substring: brand strings are attacker-influenced
- * free text, and a substring rule is how "Search Browser" becomes `arc`.
- */
 const BRAND_BY_NAME = {
     'google chrome': BrowserBrand.CHROME,
     chrome: BrowserBrand.CHROME,
@@ -44,19 +28,9 @@ const BRAND_BY_NAME = {
     firefox: BrowserBrand.FIREFOX,
     safari: BrowserBrand.SAFARI,
 };
-/** Chromium's own filler entries: the greased `Not_A Brand` (spelt differently every release) and the generic engine name. */
 function isFiller(name) {
     return 'chromium' === name || (name.includes('not') && name.includes('brand'));
 }
-/**
- * The brand, from `navigator.userAgentData.brands` where it exists and the UA string where it does
- * not (Firefox and Safari expose no userAgentData at all). Every fork claims `Google Chrome`
- * alongside its own entry, so a non-Chrome match always wins; a Chromium that names nothing but
- * filler is `other`, because calling it Chrome would be a guess.
- *
- * Never throws — a desktop webview may expose a `userAgentData` of any shape, and health reporting
- * must survive it.
- */
 function detectBrand() {
     try {
         const nav = navigator;
@@ -79,7 +53,6 @@ function detectBrand() {
         }
     }
     catch {
-        /* a health report must never depend on an exotic userAgentData */
     }
     const ua = navigator.userAgent;
     if (/Edg\//.test(ua))
@@ -103,11 +76,6 @@ function snapshotHealth() {
         brand: detectBrand(),
     };
 }
-/**
- * Report page visibility/focus immediately on change + a lightweight native heartbeat.
- * Lets the bridge know whether the tab is foregrounded so the agent never drives a throttled
- * tab blind. Uses a native (pre-bound) timer so a frozen app clock (reticle_clock) never stalls it.
- */
 export function installHealth(emit) {
     const ac = new AbortController();
     const { signal } = ac;
@@ -117,7 +85,7 @@ export function installHealth(emit) {
     document.addEventListener('visibilitychange', () => report(HealthReason.VISIBILITY), { signal });
     window.addEventListener('focus', () => report(HealthReason.FOCUS), { signal });
     window.addEventListener('blur', () => report(HealthReason.BLUR), { signal });
-    report(HealthReason.INITIAL); // baseline so the server knows state before the first change
+    report(HealthReason.INITIAL);
     const stopHeartbeat = nativeSetInterval(() => report(HealthReason.HEARTBEAT), SESSION_HEALTH.HEARTBEAT_MS);
     return () => {
         stopHeartbeat();

package/dist/observers/install-all.d.ts

@@ -1,6 +1,8 @@
 import type { Emit, Teardown } from './types.js';
 interface InstallOptions {
     captureBodies: boolean;
+    captureErrorBodies?: boolean;
 }
+export declare function runTeardowns(emit: Emit, teardowns: readonly Teardown[]): void;
 export declare function installAllObservers(emit: Emit, options: InstallOptions): Teardown[];
 export {};

package/dist/observers/install-all.js

@@ -1,16 +1,3 @@
-/**
- * Install every page observer, guarded.
- *
- * Extracted from `reticle.ts` because it is one job with one rule, and because that file is the SDK's
- * public surface — the more of this that lived there, the harder it was to see what `connect()`
- * actually does.
- *
- * THE RULE: one observer failing must never stop the others. This array used to be built bare, so a
- * single `install*` that threw took the whole `connect()` down with it — one bad patch on one exotic
- * page and the app got no instrumentation at all, silently, because the SDK\'s own catch blocks
- * ensured nobody ever found out. Each install is now wrapped: the healthy observers still run, the
- * failure is reported over the bridge, and the caller gets a teardown list of the same length.
- */
 import { installDom } from './dom.js';
 import { installStorage } from './storage.js';
 import { installStoreState } from './state.js';
@@ -22,47 +9,59 @@ import { installNetwork } from './network.js';
 import { installIpc, ipcNetOverrides, isReticleOwnIpc } from './ipc.js';
 import { installPerf } from './perf.js';
 import { installRoute } from './route.js';
+import { installNavigation } from './navigation.js';
+import { installDeparture } from './departure.js';
 import { installConsole } from './console.js';
+import { installDialogs } from './dialogs.js';
 import { installAnimation } from './animation.js';
 import { installScroll } from './scroll.js';
 import { installHealth } from './health.js';
 import { reportSdkFailure, SdkSite } from './sdk-failure.js';
-/** Run one install, reporting rather than throwing if it cannot start. */
 function guard(emit, site, install) {
     try {
         return install();
     }
     catch (error) {
         reportSdkFailure(emit, site, error);
-        return () => { }; // nothing was installed, so there is nothing to tear down
+        return () => { };
+    }
+}
+export function runTeardowns(emit, teardowns) {
+    for (const teardown of teardowns) {
+        try {
+            teardown();
+        }
+        catch (error) {
+            reportSdkFailure(emit, SdkSite.TEARDOWN, error);
+        }
     }
 }
 export function installAllObservers(emit, options) {
     return [
-        // Composition happens HERE, not inside the network observer: the network observer knows
-        // nothing about desktop IPC, and the IPC observer knows nothing about fetch plumbing.
         guard(emit, SdkSite.NETWORK_OBSERVER, () => installNetwork(emit, {
             captureBodies: options.captureBodies,
+            ...(options.captureErrorBodies === undefined
+                ? {}
+                : { captureErrorBodies: options.captureErrorBodies }),
             reinterpret: ipcNetOverrides,
-            // The SDK's own Tauri screenshot is a fetch like any other — skip it, or the observer
-            // reports its own captures as the app's writes.
             ignore: isReticleOwnIpc,
         })),
-        // Desktop backends are reached over IPC, not HTTP — inert on a plain web page.
         guard(emit, SdkSite.IPC_OBSERVER, () => installIpc(emit, { captureBodies: options.captureBodies })),
         guard(emit, SdkSite.ANIMATION_OBSERVER, () => installPerf(emit)),
         guard(emit, SdkSite.ROUTER_OBSERVER, () => installRoute(emit)),
+        guard(emit, SdkSite.NETWORK_OBSERVER, () => installNavigation(emit)),
+        guard(emit, SdkSite.NETWORK_OBSERVER, () => installDeparture(emit)),
         guard(emit, SdkSite.CONSOLE_OBSERVER, () => installConsole(emit)),
+        guard(emit, SdkSite.CONSOLE_OBSERVER, () => installDialogs(emit)),
         guard(emit, SdkSite.ANIMATION_OBSERVER, () => installAnimation(emit)),
         guard(emit, SdkSite.DOM_OBSERVER, () => installScroll(emit)),
         guard(emit, SdkSite.DOM_OBSERVER, () => installDom(emit)),
-        guard(emit, SdkSite.STORE_ADAPTER, () => installStorage(emit)), // storage WRITES → STORAGE_CHANGE diffs (pull remains the fallback)
-        guard(emit, SdkSite.STORE_ADAPTER, () => installStoreState(emit)), // subscribed-store mutations → STATE_CHANGE path diffs
-        guard(emit, SdkSite.DOM_OBSERVER, () => installFocus(emit)), // element focus movement → FOCUS_CHANGE (focus-to-body = a regression)
-        // Files the app PRODUCES — never cross the network, so no outside-the-page tool can see them.
+        guard(emit, SdkSite.STORE_ADAPTER, () => installStorage(emit)),
+        guard(emit, SdkSite.STORE_ADAPTER, () => installStoreState(emit)),
+        guard(emit, SdkSite.DOM_OBSERVER, () => installFocus(emit)),
         guard(emit, SdkSite.NETWORK_OBSERVER, () => installDownload(emit, { capturePreview: options.captureBodies })),
-        guard(emit, SdkSite.DOM_OBSERVER, () => installBlindSpots(emit)), // cross-origin iframes the SDK can't see → BLIND_SPOT (coverage: partial)
-        guard(emit, SdkSite.HEALTH_OBSERVER, () => installHealth(emit)), // page visibility/focus health + heartbeat
-        guard(emit, SdkSite.DOM_OBSERVER, () => installContextOpen(emit)), // window.open → CONTEXT_OPENED (the consequence may live in another context)
+        guard(emit, SdkSite.DOM_OBSERVER, () => installBlindSpots(emit)),
+        guard(emit, SdkSite.HEALTH_OBSERVER, () => installHealth(emit)),
+        guard(emit, SdkSite.DOM_OBSERVER, () => installContextOpen(emit)),
     ];
 }

package/dist/observers/ipc.d.ts

@@ -1,32 +1,7 @@
 import type { Emit, Teardown } from './types.js';
-/**
- * Fields to override on a NET_REQUEST that turned out to be a Tauri IPC call, or null when the
- * request was ordinary HTTP. Pure — the network observer calls this with the response header it
- * already holds, so IPC knowledge stays in this file.
- */
 export declare function ipcNetOverrides(url: string, header: (name: string) => string | null): Record<string, unknown> | undefined;
-/**
- * Is this fetch Reticle's OWN desktop call rather than the app's?
- *
- * Tauri has no preload stage, so `reticle_screenshot` reaches the shell the only way it can: an
- * `invoke` — and an invoke IS a fetch to the `ipc://` protocol, straight through the patch the
- * network observer installed. So the observer recorded its own screenshots as app IPC calls, and
- * because `IPC` counts as a mutating method, three concurrent captures inside one action window came
- * back to the agent as `duplicate-request`: "the same write fired 3 times", against an app that had
- * never made the call. Accusing a correct app of a double submit is the most damaging thing a
- * verification tool can do, and here the tool was the one submitting.
- *
- * Electron never had this problem — its preload captures through the UNPATCHED invoke for exactly
- * this reason — and the bridge's own WebSocket is skipped on the same principle (`isBridgeSocket`).
- * The capture command is the SDK's whole Tauri-side surface, so matching it is the whole rule.
- */
 export declare function isReticleOwnIpc(url: string): boolean;
-/**
- * Subscribe to the Electron preload shim, if this app installed it. Inert on Tauri (whose calls the
- * network observer handles) and on a plain web page.
- */
 interface IpcOptions {
-    /** Forward the IPC payloads the preload recorded. Off by default, like the HTTP body capture. */
     captureBodies?: boolean;
 }
 export declare function installIpc(emit: Emit, options?: IpcOptions): Teardown;

package/dist/observers/ipc.js

@@ -1,32 +1,9 @@
 import { BlindSpotKind, EventType, IPC_URL_SCHEME, IpcStatus, NetInitiator, RETICLE_IPC_GLOBAL, RETICLE_TAURI_CAPTURE_COMMAND, } from '@reticlehq/core';
 import { observeSafely } from './types.js';
-/**
- * How Tauri v2 reports a command's verdict. The transport answers HTTP 200 whether the Rust command
- * returned Ok or Err — the verdict is in this response header, which Tauri explicitly CORS-exposes so
- * JS may read it. Without translating it, every failed command is recorded as a successful request.
- */
 const TAURI_RESPONSE_HEADER_NAME = 'Tauri-Response';
 const TAURI_RESPONSE_ERROR = 'error';
-/** Rust/IPC vocabulary rather than HTTP's, so the text never claims a transport status it lacks. */
 const IPC_STATUS_TEXT = { OK: 'Ok', ERROR: 'Err' };
-/**
- * Tauri's IPC endpoint. The last path segment is the command name.
- *
- * TWO spellings, because Tauri v2 uses a different one per platform and matching only the first is a
- * silent false green on Windows: macOS/Linux get the custom scheme `ipc://localhost/archive_todo`,
- * while Windows (and Android) need a real http origin and get
- * `http://ipc.localhost/archive_todo` — the hostname `desktop-doctor` already tells people to put in
- * their CSP. Unmatched, a Windows `invoke` was recorded as an ordinary HTTP request, so the
- * `Tauri-Response` translation never ran and every command that returned `Err` was banked as a
- * successful 200. `.localhost` is reserved for loopback by RFC 6761, so this can never match a
- * remote host.
- */
 const TAURI_IPC_URL = /^(?:ipc:\/\/[^/]*|https?:\/\/ipc\.localhost(?::\d+)?)\/(.+)$/;
-/**
- * Fields to override on a NET_REQUEST that turned out to be a Tauri IPC call, or null when the
- * request was ordinary HTTP. Pure — the network observer calls this with the response header it
- * already holds, so IPC knowledge stays in this file.
- */
 export function ipcNetOverrides(url, header) {
     const match = TAURI_IPC_URL.exec(url);
     const command = match?.[1];
@@ -34,53 +11,23 @@ export function ipcNetOverrides(url, header) {
         return undefined;
     const ok = header(TAURI_RESPONSE_HEADER_NAME) !== TAURI_RESPONSE_ERROR;
     return {
-        // Normalize `ipc://localhost/archive_todo` to `ipc://archive_todo`, so a Tauri command and an
-        // Electron channel read identically to the agent and to a saved flow's assertions.
         url: `${IPC_URL_SCHEME}${command}`,
         initiator: NetInitiator.IPC,
         method: NetInitiator.IPC,
         ok,
         status: ok ? IpcStatus.OK : IpcStatus.ERROR,
-        // Overwrite the TRANSPORT's statusText. Tauri's fetch genuinely answered 200/"OK", so letting it
-        // through beside a synthetic 500 produced a record that contradicted itself — `status: 500,
-        // statusText: "OK"` reads as nonsense to anyone seeing it cold. The record must tell one story,
-        // and the story that matters is the command's verdict, not the pipe it travelled down.
         statusText: ok ? IPC_STATUS_TEXT.OK : IPC_STATUS_TEXT.ERROR,
     };
 }
-/**
- * Is this fetch Reticle's OWN desktop call rather than the app's?
- *
- * Tauri has no preload stage, so `reticle_screenshot` reaches the shell the only way it can: an
- * `invoke` — and an invoke IS a fetch to the `ipc://` protocol, straight through the patch the
- * network observer installed. So the observer recorded its own screenshots as app IPC calls, and
- * because `IPC` counts as a mutating method, three concurrent captures inside one action window came
- * back to the agent as `duplicate-request`: "the same write fired 3 times", against an app that had
- * never made the call. Accusing a correct app of a double submit is the most damaging thing a
- * verification tool can do, and here the tool was the one submitting.
- *
- * Electron never had this problem — its preload captures through the UNPATCHED invoke for exactly
- * this reason — and the bridge's own WebSocket is skipped on the same principle (`isBridgeSocket`).
- * The capture command is the SDK's whole Tauri-side surface, so matching it is the whole rule.
- */
 export function isReticleOwnIpc(url) {
     return TAURI_IPC_URL.exec(url)?.[1] === RETICLE_TAURI_CAPTURE_COMMAND;
 }
-/**
- * Is this page an Electron renderer? Read off the user agent, which Electron stamps and which is
- * available whether or not the preload ran — the whole point is to recognise a renderer that has
- * NOT been instrumented.
- */
 function isElectronRenderer() {
     return navigator.userAgent.includes('Electron');
 }
 export function installIpc(emit, options = {}) {
     const channel = window[RETICLE_IPC_GLOBAL];
     if (typeof channel?.subscribe !== 'function') {
-        // No shim — but on Electron that is not "nothing to observe", it is "everything unobserved".
-        // Tauri needs no shim (its invoke travels as a fetch) and a web page has no IPC at all, so only
-        // Electron gets the declaration. Saying nothing here is what let a missing preload line read as
-        // a clean, empty network view for a whole app.
         if (isElectronRenderer())
             emit(EventType.BLIND_SPOT, { kind: BlindSpotKind.UNOBSERVED_IPC, count: 1 });
         return () => undefined;
@@ -97,13 +44,7 @@ export function installIpc(emit, options = {}) {
                 });
                 return;
             }
-            // A one-way `send` that did not throw has NO verdict — the renderer never learns whether the
-            // main process handled it. Emitting `ok/status` anyway would manufacture the success nobody
-            // reported, so both are omitted and `oneWay` says why. `reticle_network { ok }` then matches
-            // such a record in neither direction, which is the honest answer to "did it work".
             const verdictless = true === record.oneWay && record.ok === undefined;
-            // Declared, not inferred: the server cannot tell "no verdict" from "not yet settled" without
-            // being told, and a send with nothing to observe must not read as a clean green.
             if (verdictless)
                 emit(EventType.BLIND_SPOT, { kind: BlindSpotKind.VERDICTLESS_SEND, count: 1 });
             const ok = true === record.ok;
@@ -116,9 +57,6 @@ export function installIpc(emit, options = {}) {
                 durationMs: record.durationMs ?? 0,
                 initiator: NetInitiator.IPC,
                 ...(record.error === undefined ? {} : { error: record.error }),
-                // Size travels ALWAYS, bodies only on opt-in. The split matters: the verdict layer reports "a
-                // write returned ok and its payload went unread" from the size alone, and it cannot infer that
-                // from an absent field — an unread payload and an empty one would look identical.
                 ...(record.responseSize === undefined ? {} : { responseSize: record.responseSize }),
                 ...(true === options.captureBodies
                     ? {
@@ -130,9 +68,6 @@ export function installIpc(emit, options = {}) {
             });
         });
     });
-    // A REAL removal, so teardown leaves the app as it found it. The preload's `invoke` patch stays
-    // deliberately — it is a pass-through with no effect once no subscriber remains, and un-patching
-    // mid-flight would strand any call already inside the wrapper.
     return () => {
         channel.unsubscribe?.(token);
     };

package/dist/observers/navigation.d.ts

@@ -0,0 +1,2 @@
+import type { Emit, Teardown } from './types.js';
+export declare function installNavigation(emit: Emit): Teardown;

package/dist/observers/navigation.js

@@ -0,0 +1,33 @@
+import { EventType, NetInitiator } from '@reticlehq/core';
+const REPORTED_TYPES = new Set(['navigate', 'reload', 'back_forward']);
+function navigationEntry() {
+    try {
+        const [first] = performance.getEntriesByType('navigation');
+        return first;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function installNavigation(emit) {
+    const entry = navigationEntry();
+    const type = entry?.type;
+    const url = entry?.name;
+    if (entry === undefined || 'string' !== typeof url || 0 === url.length)
+        return () => undefined;
+    if ('string' !== typeof type || !REPORTED_TYPES.has(type))
+        return () => undefined;
+    const status = entry.responseStatus;
+    const known = 'number' === typeof status && status > 0;
+    emit(EventType.NET_REQUEST, {
+        id: `doc-${String(Math.round(entry.duration ?? 0))}`,
+        method: 'GET',
+        url,
+        initiator: NetInitiator.DOCUMENT,
+        durationMs: Math.round(entry.duration ?? 0),
+        ...(known ? { status, ok: status < 400 } : {}),
+        navigationType: type,
+        ...('number' === typeof entry.transferSize ? { transferSize: entry.transferSize } : {}),
+    });
+    return () => undefined;
+}

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

@@ -0,0 +1,12 @@
+export declare function isStreamingBody(contentType: string | null, contentLength: string | null): boolean;
+export declare function withBodyDeadline(read: Promise<string>): Promise<string | undefined>;
+export declare function isCapturableType(contentType: string | null): boolean;
+export declare function shouldCaptureErrorBody(status: number, enabled: boolean): boolean;
+export declare function projectErrorBody(rawText: string, contentType: string | null): {
+    body: string;
+    truncated: boolean;
+};
+export declare function projectBody(rawText: string, contentType: string | null): {
+    body: string;
+    truncated: boolean;
+};

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

@@ -0,0 +1,71 @@
+import { REDACTED_VALUE } from '@reticlehq/core';
+import { isSensitiveKey, safeStringify, scrubKnownSecrets } from '../../security/serialization.js';
+import { nativeClearTimeout, nativeSetTimeout } from '../../timers/native/native-timers.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))
+        return false;
+    return null === contentLength;
+}
+const BODY_READ_TIMEOUT_MS = 500;
+export async function withBodyDeadline(read) {
+    let timer;
+    try {
+        return await Promise.race([
+            read,
+            new Promise((resolve) => {
+                timer = nativeSetTimeout(() => resolve(undefined), BODY_READ_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            nativeClearTimeout(timer);
+    }
+}
+export function isCapturableType(contentType) {
+    if (null === contentType)
+        return false;
+    if (STREAMING_CONTENT.test(contentType))
+        return false;
+    return CAPTURABLE_CONTENT.test(contentType);
+}
+const MAX_BODY_CHARS = 8192;
+const MAX_BODY_SCAN_CHARS = MAX_BODY_CHARS * 2;
+const AUTH_SCHEME_TOKEN = /\b(Bearer|Basic)\s+(?=[A-Za-z0-9._~+/=-]{16,})(?=[A-Za-z0-9._~+/=-]*[\d._~+/=-])[A-Za-z0-9._~+/=-]+/gi;
+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));
+}
+const ERROR_BODY_CHARS = 4096;
+export function shouldCaptureErrorBody(status, enabled) {
+    return enabled && status >= 400;
+}
+export function projectErrorBody(rawText, contentType) {
+    const projected = projectBody(rawText, contentType);
+    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) {
+    const oversized = rawText.length > MAX_BODY_SCAN_CHARS;
+    const text = oversized ? rawText.slice(0, MAX_BODY_SCAN_CHARS) : rawText;
+    let out;
+    if (contentType !== null && /json|graphql/i.test(contentType)) {
+        try {
+            out = safeStringify(JSON.parse(text));
+        }
+        catch {
+            out = redactText(text);
+        }
+    }
+    else {
+        out = redactText(text);
+    }
+    out = scrubKnownSecrets(out);
+    const truncated = oversized || out.length > MAX_BODY_CHARS;
+    return { body: out.length > MAX_BODY_CHARS ? out.slice(0, MAX_BODY_CHARS) : out, truncated };
+}

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

@@ -0,0 +1 @@
+export { netUrlFields, redactUrl } from '@reticlehq/core';

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

@@ -0,0 +1 @@
+export { netUrlFields, redactUrl } from '@reticlehq/core';

package/dist/observers/network-stream.d.ts

@@ -1,23 +1,2 @@
 import type { Emit } from './types.js';
-/**
- * Watch a STREAMED response body to its end, so `settled` cannot pass while the server is still
- * writing.
- *
- * `fetch` resolves at HEADERS. On a Next.js App Router page the RSC payload's NET_REQUEST landed
- * 16 ms in, the shell rendered at 3013, and the Suspense boundary's rows arrived at 3902 — 889 ms
- * in which NOTHING was observed. Quiet is exactly what settle tests for, so it passed with the
- * fallback still on screen and zero rows rendered: a green on every streaming boundary.
- *
- * STRUCTURAL, not an allowlist: a response with a body and no `content-length` is being sent
- * chunked, which is the wire's own way of saying the server is still writing. An earlier version
- * gated on a content-type list containing `x-component` — "Next.js RSC, plus two guesses" — which
- * closed the one defect it was written against and left every other streamed response as invisible
- * as before. The clone is DRAINED as it arrives rather than buffered, so watching costs a second
- * read of bytes already in flight, not a second copy held in memory.
- *
- * BOUNDED both ways: an endless stream (SSE over fetch, a live feed) must not hold `settled` open
- * forever, so the watch gives up after STREAM_WATCH_MS and closes the record anyway, marked
- * `gaveUp`. That is the safe direction — a settle that eventually proceeds beats one that never
- * does — and it says which happened rather than pretending the stream ended.
- */
 export declare function watchStreamedBody(emit: Emit, res: Response, id: string, url: string, contentType: string | null, contentLength: string | null): void;

package/dist/observers/network-stream.js

@@ -1,46 +1,8 @@
-/**
- * Watching a STREAMED response body to its end, so `settled` cannot pass mid-stream.
- *
- * Split out of network.ts, which was already at its line cap. One question: when did this response
- * actually finish arriving?
- */
 import { EventType, StreamDirection, StreamTransport } from '@reticlehq/core';
-import { isStreamingBody } from './network-body.js';
-import { nativeClearTimeout, nativeSetTimeout } from '../timers/native-timers.js';
-/**
- * Longest a streamed response body is watched before the record is closed anyway.
- *
- * An endless stream must never hold `settled` open forever. Ten seconds is longer than any
- * page-render stream and short enough that a genuinely endless one costs one settle window, not the
- * session.
- */
+import { isStreamingBody } from './net-detail/network-body.js';
+import { nativeClearTimeout, nativeSetTimeout } from '../timers/native/native-timers.js';
 const STREAM_WATCH_MS = 10_000;
-/**
- * Watch a STREAMED response body to its end, so `settled` cannot pass while the server is still
- * writing.
- *
- * `fetch` resolves at HEADERS. On a Next.js App Router page the RSC payload's NET_REQUEST landed
- * 16 ms in, the shell rendered at 3013, and the Suspense boundary's rows arrived at 3902 — 889 ms
- * in which NOTHING was observed. Quiet is exactly what settle tests for, so it passed with the
- * fallback still on screen and zero rows rendered: a green on every streaming boundary.
- *
- * STRUCTURAL, not an allowlist: a response with a body and no `content-length` is being sent
- * chunked, which is the wire's own way of saying the server is still writing. An earlier version
- * gated on a content-type list containing `x-component` — "Next.js RSC, plus two guesses" — which
- * closed the one defect it was written against and left every other streamed response as invisible
- * as before. The clone is DRAINED as it arrives rather than buffered, so watching costs a second
- * read of bytes already in flight, not a second copy held in memory.
- *
- * BOUNDED both ways: an endless stream (SSE over fetch, a live feed) must not hold `settled` open
- * forever, so the watch gives up after STREAM_WATCH_MS and closes the record anyway, marked
- * `gaveUp`. That is the safe direction — a settle that eventually proceeds beats one that never
- * does — and it says which happened rather than pretending the stream ended.
- */
 export function watchStreamedBody(emit, res, id, url, contentType, contentLength) {
-    // `=== null` is not enough: jsdom's Response has no `body` at all, and older/polyfilled
-    // implementations return undefined. Reaching for `.getReader()` on that threw an unhandled
-    // rejection out of a detached promise — an observability layer throwing into the host page, from
-    // code the host never called. Duck-type the reader instead of trusting the shape.
     if (!isStreamingBody(contentType, contentLength))
         return;
     if (typeof res.body?.getReader !== 'function')
@@ -50,7 +12,7 @@ export function watchStreamedBody(emit, res, id, url, contentType, contentLength
         clone = res.clone();
     }
     catch {
-        return; // already consumed or locked — the app owns it; observing it would take it away
+        return;
     }
     const body = clone.body;
     if (null === body)
@@ -64,10 +26,6 @@ export function watchStreamedBody(emit, res, id, url, contentType, contentLength
     void (async () => {
         const reader = body.getReader();
         let gaveUp = false;
-        // The deadline must be a TIMER, not a check after each read. An idle stream parks inside
-        // `read()` waiting for a chunk that may never come, so a post-read check never runs and the
-        // record never closes — which would hold `settled` open forever on exactly the endless streams
-        // the bound exists to protect against.
         let timer;
         const expired = new Promise((resolve) => {
             timer = nativeSetTimeout(() => resolve('expired'), STREAM_WATCH_MS);
@@ -85,7 +43,6 @@ export function watchStreamedBody(emit, res, id, url, contentType, contentLength
             }
         }
         catch {
-            /* aborted or errored — the stream is over either way, which is what we report */
         }
         finally {
             if (timer !== undefined)