@reticlehq/browser 2.13.0 → 2.14.0

package/dist/observers/dialogs.js

@@ -0,0 +1,39 @@
+import { EventType } from '@reticlehq/core';
+import { observeSafely } from './types.js';
+import { isSyntheticInput } from '../actions/synthetic-input.js';
+const DECLINED = { alert: undefined, confirm: false, prompt: null };
+const KINDS = ['alert', 'confirm', 'prompt'];
+export function installDialogs(emit) {
+    const slots = window;
+    const originals = new Map();
+    const patched = new Map();
+    for (const kind of KINDS) {
+        const original = slots[kind];
+        if ('function' !== typeof original)
+            continue;
+        originals.set(kind, original);
+        const callOriginal = original.bind(window);
+        const wrapper = (...args) => {
+            if (!isSyntheticInput())
+                return callOriginal(...args);
+            const answered = DECLINED[kind];
+            const message = args[0];
+            observeSafely(() => {
+                emit(EventType.DIALOG_OPENED, {
+                    kind,
+                    ...('string' === typeof message ? { message } : {}),
+                    ...(answered === undefined ? {} : { answered }),
+                });
+            });
+            return answered;
+        };
+        patched.set(kind, wrapper);
+        slots[kind] = wrapper;
+    }
+    return () => {
+        for (const [kind, original] of originals) {
+            if (slots[kind] === patched.get(kind))
+                slots[kind] = original;
+        }
+    };
+}

package/dist/observers/dom.js

@@ -1,12 +1,6 @@
 import { EventType, TruncationChannel } from '@reticlehq/core';
 import { getAccessibleName, getRole, isVisible } from '../dom/a11y.js';
 import { refs } from '../dom/refs.js';
-/**
- * A STABLE identity for the region a mutation happened in. Ambient learning cannot key on the element
- * ref for a churning list: every appended row is a NEW element (fresh ref) and a removed one has no ref
- * at all, so per-ref counts never accumulate and the region is never recognized as ambient. The
- * container persists across ticks, so its testid (or ref) is the identity that does accumulate.
- */
 function regionKeyOf(target) {
     const el = isElement(target) ? target : null;
     if (null === el)
@@ -28,13 +22,11 @@ const WATCHED_ATTRS = [
     'aria-selected',
     'aria-checked',
     'data-state',
-    // Widened: visual + resource + form-value attributes. Values are capped (they can be long).
     'style',
     'src',
     'href',
     'value',
 ];
-/** Attribute/text values are capped per event — style/src can be huge and would bloat the ledger. */
 const MAX_ATTR_VALUE_LEN = 120;
 function capValue(value) {
     if (null === value)
@@ -43,24 +35,14 @@ function capValue(value) {
 }
 const DIALOG_ROLES = new Set(['dialog', 'alertdialog']);
 const LIVE_ROLES = new Set(['alert', 'status']);
-/** Max meaningful added/removed nodes reported per mutation batch (backpressure). */
 const MAX_PER_BATCH = 40;
 function isMeaningful(role, name) {
     return role !== 'generic' || name.length > 0;
 }
-/** Observe DOM mutations and emit semantic (not raw) events. */
-/**
- * The trimmed text carried by a node list, or undefined when it carries none.
- *
- * Whitespace-only nodes are ignored deliberately: a re-render that reshuffles indentation would
- * otherwise emit a text change on every layout node, which is noise the timeline cannot afford.
- */
 const TEXT_NODE = 3;
 function textOf(nodes) {
     let out = '';
     for (const node of nodes) {
-        // The numeric nodeType, not `Node.TEXT_NODE`: the global `Node` constructor is not guaranteed to
-        // exist wherever this runs, and referencing it threw a ReferenceError rather than degrading.
         if (node.nodeType !== TEXT_NODE)
             continue;
         out += node.nodeValue ?? '';
@@ -69,17 +51,11 @@ function textOf(nodes) {
     return trimmed.length > 0 ? trimmed : undefined;
 }
 export function installDom(emit) {
-    // Installed here rather than in the bootstrap list because this observer is the registry's reason
-    // for existing, and the ordering matters: a root attached between the two would be missed by both.
-    // It is also the only chance to capture a CLOSED root, which attachShadow returns exactly once.
     const stopRegistry = installShadowRegistry();
     const observer = new MutationObserver((records) => {
         let added = 0;
         let removed = 0;
         let changed = 0;
-        // Count element nodes dropped purely because a per-batch cap was already reached. The cap is on
-        // MEANINGFUL events, so it is only hit after a real flood — the count is a raw over-estimate
-        // (it can include not-yet-inspected noise) but `dropped > 0` honestly means "this batch was capped".
         let dropped = 0;
         for (const record of records) {
             if ('attributes' === record.type) {
@@ -90,7 +66,6 @@ export function installDom(emit) {
                         continue;
                     }
                     changed += 1;
-                    // Old value (attributeOldValue) + capped new value — a diff, not just a reading.
                     const value = capValue(target.getAttribute(record.attributeName));
                     const old = capValue(record.oldValue);
                     emit(EventType.DOM_ATTR, {
@@ -102,8 +77,6 @@ export function installDom(emit) {
                 continue;
             }
             if ('characterData' === record.type) {
-                // In-place text change inside an existing subtree (wizard steps, inline edits) —
-                // childList-only would miss this.
                 const parent = record.target.parentElement;
                 if (parent !== null && !isReticleOverlay(parent)) {
                     if (changed >= MAX_PER_BATCH) {
@@ -117,14 +90,6 @@ export function installDom(emit) {
                 }
                 continue;
             }
-            // A TEXT node arriving or leaving is a text change, and it is the ordinary one. `characterData`
-            // fires only when an EXISTING text node's `data` is edited in place; `el.textContent = x`,
-            // `innerText`, and React replacing a child all REPLACE the node instead — a childList mutation
-            // carrying a Text node, which the Element-only loops below skip. Measured on a live page:
-            // `firstChild.data = x` emitted `dom.text`, while `textContent`, `innerText` and
-            // `appendChild(createTextNode())` emitted NOTHING. So the most common visible change an app
-            // makes — updating text — produced no event at all, `reticle_observe` reported "nothing
-            // happened" over a screen that had visibly changed, and `settled` went quiet immediately.
             if (textOf(record.addedNodes) !== undefined || textOf(record.removedNodes) !== undefined) {
                 const parent = isElement(record.target) ? record.target : null;
                 if (parent !== null && !isReticleOverlay(parent)) {
@@ -132,8 +97,6 @@ export function installDom(emit) {
                         dropped += 1;
                     else {
                         changed += 1;
-                        // The element's text AFTER the mutation, so a cleared node reports '' rather than the
-                        // text that just left — the reader wants what is on screen now.
                         const text = (parent.textContent ?? '').trim().slice(0, 80);
                         const old = capValue(textOf(record.removedNodes) ?? null);
                         emit(EventType.DOM_TEXT, { text, ...(old === undefined ? {} : { old }) }, refs.refFor(parent));
@@ -177,12 +140,9 @@ export function installDom(emit) {
                 if (!isMeaningful(role, name))
                     continue;
                 removed += 1;
-                // A removed node has no ref (it is gone), so the CONTAINER is the only stable identity — and it
-                // is what ambient learning needs to recognize a churning region.
                 emit(EventType.DOM_REMOVED, { role, name, region: regionKeyOf(record.target) });
             }
         }
-        // Never silent: a capped batch tells the ledger its DOM counts understate reality.
         if (dropped > 0)
             emit(EventType.TRUNCATED, { channel: TruncationChannel.DOM, dropped });
     });
@@ -196,13 +156,9 @@ export function installDom(emit) {
         characterDataOldValue: true,
     };
     observer.observe(document.documentElement, options);
-    // A MutationObserver does NOT cross a shadow boundary, so every root needs its own observation.
-    // Without this, a click that changed text inside a web component produced an empty observe window —
-    // the same shape as an app that ignored the click entirely.
     for (const root of capturedRoots())
         observer.observe(root, options);
     const unsubscribe = onShadowRoot((root) => observer.observe(root, options));
-    // Same-origin frame documents are separate node trees for the same reason, with the same symptom.
     const stopFrames = observeSameOriginFrames((body) => observer.observe(body, options));
     return () => {
         stopFrames();

package/dist/observers/download.d.ts

@@ -1,6 +1,5 @@
-import type { Emit, Teardown } from './types.js';
+import { type Emit, type Teardown } from './types.js';
 interface DownloadOptions {
-    /** Include a content preview. Gated for the same reason request bodies are: exports hold PII. */
     capturePreview?: boolean;
 }
 export declare function installDownload(emit: Emit, opts?: DownloadOptions): Teardown;

package/dist/observers/download.js

@@ -1,58 +1,37 @@
 import { EventType } from '@reticlehq/core';
 import { captureMethod } from '../patching/capture-method.js';
 import { projectBody } from './network-body.js';
-/**
- * Files the app PRODUCES — the one artifact class an outside-the-browser tool cannot inspect.
- *
- * A generated export never crosses the network: the app builds a Blob, hands it to
- * `URL.createObjectURL`, and clicks an anchor. There is no request to intercept, and Playwright MCP
- * has no tool that returns a downloaded file at all. Reticle runs inside the page, where the Blob is
- * constructed, so the export is observable before it reaches the disk.
- *
- * Measured on a real merchant dashboard: one Export click produced a CSV wrong three ways at once —
- * 25 data rows in a file named `transactions-128-rows.csv`, an unquoted `3 Aug, 10:00 pm` that
- * shifts every column after it, and an `amount_inr` header over rows denominated in USD — while the
- * click itself reported a clean success and every other channel agreed. The benchmark's ground truth
- * records those three as missed by BOTH toolchains, for the same reason: nobody opened the file.
- */
-/** Text-like types worth counting lines in and previewing. Anything else reports type + size only. */
+import { observeSafely, observeValue } from './types.js';
 const TEXTUAL = /text\/|json|csv|xml|ndjson|javascript/i;
-/** Lines are reported for text files; the preview is capped and redacted by projectBody. */
 const PREVIEW_CHARS = 2000;
 export function installDownload(emit, opts = {}) {
-    // jsdom does not implement `createObjectURL`, and plenty of users run this SDK under jsdom in their
-    // own test suite. Reaching for `.bind` on an absent function threw during `connect()` — an
-    // observability layer taking the host app down with it, which is the one failure mode it may never
-    // have. No object URLs means no generated files to observe, so this simply stands down.
     if (typeof URL.createObjectURL !== 'function')
         return () => undefined;
     const objectUrl = URL.createObjectURL.bind(URL);
     const known = new Map();
-    /**
-     * `createObjectURL` is where the file becomes real. The filename is NOT here — it lives on the
-     * anchor that gets clicked — so the blob is remembered against its URL and reported when either
-     * the anchor fires or, failing that, on a microtask so a download that is never clicked (a
-     * generated preview, an <img> src) is still visible.
-     */
     const originalCreate = captureMethod(URL, 'createObjectURL');
-    URL.createObjectURL = function reticleObservedObjectUrl(obj) {
+    const patchedCreate = function reticleObservedObjectUrl(obj) {
         const url = objectUrl(obj);
-        if (typeof Blob !== 'undefined' && obj instanceof Blob) {
-            // Started here, awaited at report time — never blocking the app's own download path.
-            const text = TEXTUAL.test(obj.type)
-                ? obj.text().catch(() => undefined)
-                : Promise.resolve(undefined);
-            known.set(url, { type: obj.type, size: obj.size, text });
-        }
+        observeSafely(() => {
+            if (typeof Blob !== 'undefined' && obj instanceof Blob) {
+                const text = TEXTUAL.test(obj.type)
+                    ? obj.text().catch(() => undefined)
+                    : Promise.resolve(undefined);
+                known.set(url, { type: obj.type, size: obj.size, text });
+            }
+        });
         return url;
     };
+    URL.createObjectURL = patchedCreate;
     const report = (url, filename) => {
         const record = known.get(url);
         if (record === undefined)
             return;
         known.delete(url);
         void record.text.then((text) => {
-            emitDownload(record, filename, text);
+            observeSafely(() => {
+                emitDownload(record, filename, text);
+            });
         });
     };
     const emitDownload = (record, filename, text) => {
@@ -60,8 +39,6 @@ export function installDownload(emit, opts = {}) {
         if (filename !== undefined && filename.length > 0)
             data['filename'] = filename;
         if (text !== undefined) {
-            // The LINE COUNT is reported even without preview capture: it is a number, not content, and it
-            // is the whole tell for "25 rows in a file the toast calls 128".
             data['lines'] = text.split('\n').filter((l) => l.length > 0).length;
             if (true === opts.capturePreview) {
                 const { body, truncated } = projectBody(text.slice(0, PREVIEW_CHARS), record.type);
@@ -72,32 +49,38 @@ export function installDownload(emit, opts = {}) {
         }
         emit(EventType.DOWNLOAD, data);
     };
-    /**
-     * An anchor click carries the NAME. Captured at the document level so it sees the click whether the
-     * app dispatches it programmatically or a human does, and whether or not the anchor is in the DOM.
-     */
     const onClick = (event) => {
-        const target = event.target;
-        const anchor = target instanceof Element ? target.closest('a[download]') : null;
-        if (null === anchor)
-            return;
-        report(anchor.getAttribute('href') ?? '', anchor.getAttribute('download') ?? undefined);
+        observeSafely(() => {
+            const target = event.target;
+            const anchor = target instanceof Element ? target.closest('a[download]') : null;
+            if (null === anchor)
+                return;
+            report(anchor.getAttribute('href') ?? '', anchor.getAttribute('download') ?? undefined);
+        });
     };
     document.addEventListener('click', onClick, true);
-    // A programmatic `a.click()` on an anchor never inserted into the document dispatches no bubbling
-    // event this listener can see, so the anchor path is patched too.
     const originalClick = captureMethod(HTMLAnchorElement.prototype, 'click');
-    HTMLAnchorElement.prototype.click = function reticleObservedAnchorClick() {
-        if (this.hasAttribute('download')) {
-            report(this.getAttribute('href') ?? '', this.getAttribute('download') ?? undefined);
-        }
+    const patchedClick = function reticleObservedAnchorClick() {
+        const pending = observeValue(() => this.hasAttribute('download')
+            ? {
+                href: this.getAttribute('href') ?? '',
+                name: this.getAttribute('download') ?? undefined,
+            }
+            : undefined);
         originalClick.call(this);
+        observeSafely(() => {
+            if (pending !== undefined)
+                report(pending.href, pending.name);
+        });
     };
+    HTMLAnchorElement.prototype.click = patchedClick;
     return () => {
-        // A REAL restore, so teardown leaves the page exactly as it was found.
         document.removeEventListener('click', onClick, true);
-        URL.createObjectURL = originalCreate;
-        HTMLAnchorElement.prototype.click = originalClick;
+        if (URL.createObjectURL === patchedCreate)
+            URL.createObjectURL = originalCreate;
+        if (HTMLAnchorElement.prototype.click === patchedClick) {
+            HTMLAnchorElement.prototype.click = originalClick;
+        }
         known.clear();
     };
 }

package/dist/observers/focus.d.ts

@@ -1,9 +1,3 @@
 import type { Emit, Teardown } from './types.js';
-/** A human-legible label for a focused element, or undefined for body/none. Pure; exported for testing. */
 export declare function focusLabel(el: EventTarget | null): string | undefined;
-/**
- * Track element focus movement. Focus dropping to <body> after an act — a modal that closed and stranded
- * focus, a button that vanished — is a real accessibility/UX regression no screenshot names. Emits
- * FOCUS_CHANGE {to, from, toBody}. Reversible.
- */
 export declare function installFocus(emit: Emit): Teardown;

package/dist/observers/focus.js

@@ -1,6 +1,5 @@
 import { EventType } from '@reticlehq/core';
 import { getAccessibleName, getRole } from '../dom/a11y.js';
-/** A human-legible label for a focused element, or undefined for body/none. Pure; exported for testing. */
 export function focusLabel(el) {
     if (!(el instanceof Element) || el === document.body)
         return undefined;
@@ -11,11 +10,6 @@ export function focusLabel(el) {
 function toBody(el) {
     return null === el || el === document.body;
 }
-/**
- * Track element focus movement. Focus dropping to <body> after an act — a modal that closed and stranded
- * focus, a button that vanished — is a real accessibility/UX regression no screenshot names. Emits
- * FOCUS_CHANGE {to, from, toBody}. Reversible.
- */
 export function installFocus(emit) {
     const ac = new AbortController();
     const { signal } = ac;
@@ -31,7 +25,6 @@ export function installFocus(emit) {
         });
     };
     const onFocusOut = (event) => {
-        // Focus left with nothing gaining it → it dropped to the body (the regression case).
         if (event.relatedTarget !== null)
             return;
         const from = last;

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.
- */
 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;