@reticlehq/browser 2.4.0 → 2.6.0

package/dist/dom/realm.js

@@ -15,12 +15,12 @@
  */
 /** The constructor named `name` in the realm that owns `node`, or undefined if there isn't one. */
 function ctorIn(node, name) {
-    if (node === null || typeof node !== 'object')
+    if (null === node || typeof node !== 'object')
         return undefined;
     // A Document owns itself; every other node reports an ownerDocument.
     const doc = node.ownerDocument ?? node;
     const view = doc.defaultView;
-    if (view === null || view === undefined)
+    if (null === view || view === undefined)
         return undefined;
     return view[name];
 }
@@ -32,17 +32,17 @@ function ctorIn(node, name) {
  */
 function isIn(node, name, ambient) {
     const ctor = ctorIn(node, name) ?? ambient;
-    return typeof ctor === 'function' && node instanceof ctor;
+    return 'function' === typeof ctor && node instanceof ctor;
 }
-export const isElement = (n) => isIn(n, 'Element', typeof Element === 'undefined' ? undefined : Element);
-export const isImage = (n) => isIn(n, 'HTMLImageElement', typeof HTMLImageElement === 'undefined' ? undefined : HTMLImageElement);
-export const isHtmlElement = (n) => isIn(n, 'HTMLElement', typeof HTMLElement === 'undefined' ? undefined : HTMLElement);
-export const isInput = (n) => isIn(n, 'HTMLInputElement', typeof HTMLInputElement === 'undefined' ? undefined : HTMLInputElement);
-export const isTextArea = (n) => isIn(n, 'HTMLTextAreaElement', typeof HTMLTextAreaElement === 'undefined' ? undefined : HTMLTextAreaElement);
-export const isSelect = (n) => isIn(n, 'HTMLSelectElement', typeof HTMLSelectElement === 'undefined' ? undefined : HTMLSelectElement);
-export const isButton = (n) => isIn(n, 'HTMLButtonElement', typeof HTMLButtonElement === 'undefined' ? undefined : HTMLButtonElement);
-export const isForm = (n) => isIn(n, 'HTMLFormElement', typeof HTMLFormElement === 'undefined' ? undefined : HTMLFormElement);
-export const isFrame = (n) => isIn(n, 'HTMLIFrameElement', typeof HTMLIFrameElement === 'undefined' ? undefined : HTMLIFrameElement);
+export const isElement = (n) => isIn(n, 'Element', 'undefined' === typeof Element ? undefined : Element);
+export const isImage = (n) => isIn(n, 'HTMLImageElement', 'undefined' === typeof HTMLImageElement ? undefined : HTMLImageElement);
+export const isHtmlElement = (n) => isIn(n, 'HTMLElement', 'undefined' === typeof HTMLElement ? undefined : HTMLElement);
+export const isInput = (n) => isIn(n, 'HTMLInputElement', 'undefined' === typeof HTMLInputElement ? undefined : HTMLInputElement);
+export const isTextArea = (n) => isIn(n, 'HTMLTextAreaElement', 'undefined' === typeof HTMLTextAreaElement ? undefined : HTMLTextAreaElement);
+export const isSelect = (n) => isIn(n, 'HTMLSelectElement', 'undefined' === typeof HTMLSelectElement ? undefined : HTMLSelectElement);
+export const isButton = (n) => isIn(n, 'HTMLButtonElement', 'undefined' === typeof HTMLButtonElement ? undefined : HTMLButtonElement);
+export const isForm = (n) => isIn(n, 'HTMLFormElement', 'undefined' === typeof HTMLFormElement ? undefined : HTMLFormElement);
+export const isFrame = (n) => isIn(n, 'HTMLIFrameElement', 'undefined' === typeof HTMLIFrameElement ? undefined : HTMLIFrameElement);
 /**
  * The prototype whose native value setter drives `el` — React and friends install their own accessor
  * on the instance, so a value write has to go through the prototype's. It must come from the
@@ -54,5 +54,5 @@ export function valuePrototypeOf(el) {
     if (typeof ctor !== 'function')
         return undefined;
     const proto = ctor.prototype;
-    return typeof proto === 'object' && proto !== null ? proto : undefined;
+    return 'object' === typeof proto && proto !== null ? proto : undefined;
 }

package/dist/dom/refs.d.ts

@@ -17,6 +17,20 @@ import { type Ref } from '@reticlehq/core';
  * ref is one agent turn, and this is far more than any one turn produces.
  */
 export declare const MAX_TRACKED_REFS = 10000;
+/**
+ * A ref, made safe to interpolate into an error message.
+ *
+ * A ref Reticle mints is `e7` — three characters. A ref a CALLER passes is whatever they typed, and
+ * an agent guessing at the schema can pass 100KB of it. Every stale-ref message interpolates that
+ * value directly, so the caller's own bad argument came back as a 100KB error.
+ *
+ * The server caps error messages centrally, but it cannot help here: the browser's transport
+ * serializer truncates from the TAIL first, which severs "… no longer resolves to an element" — the
+ * exact substring the server's recovery table matches on. A stale ref then arrives classified as a
+ * possible Reticle defect. So the echo is bounded at the source, where the untrusted value enters
+ * the message.
+ */
+export declare function echoRef(ref: string): string;
 export declare class RefRegistry {
     #private;
     /** How many reverse entries are currently retained. Exposed so the bound can be asserted. */

package/dist/dom/refs.js

@@ -1,4 +1,4 @@
-import { asRef } from '@reticlehq/core';
+import { TRANSPORT_LIMITS, asRef } from '@reticlehq/core';
 /**
  * Stable, human-meaningful element handles. Each element gets a ref like `e7`; the same
  * element keeps its ref across snapshots, and a ref re-resolves to its element as long as
@@ -17,6 +17,25 @@ import { asRef } from '@reticlehq/core';
  * ref is one agent turn, and this is far more than any one turn produces.
  */
 export const MAX_TRACKED_REFS = 10000;
+/** Marks a ref that was too long to echo in full. */
+const REF_ELISION = '…';
+/**
+ * A ref, made safe to interpolate into an error message.
+ *
+ * A ref Reticle mints is `e7` — three characters. A ref a CALLER passes is whatever they typed, and
+ * an agent guessing at the schema can pass 100KB of it. Every stale-ref message interpolates that
+ * value directly, so the caller's own bad argument came back as a 100KB error.
+ *
+ * The server caps error messages centrally, but it cannot help here: the browser's transport
+ * serializer truncates from the TAIL first, which severs "… no longer resolves to an element" — the
+ * exact substring the server's recovery table matches on. A stale ref then arrives classified as a
+ * possible Reticle defect. So the echo is bounded at the source, where the untrusted value enters
+ * the message.
+ */
+export function echoRef(ref) {
+    const max = TRANSPORT_LIMITS.MAX_REF_LENGTH;
+    return max >= ref.length ? ref : `${ref.slice(0, max)}${REF_ELISION}`;
+}
 /**
  * Full-sweep cadence. The deref-sweep is O(retained), and a page legitimately holding ≥ MAX_TRACKED_REFS
  * live elements (a 10k-node dashboard) can never get under the cap that way, so running it on EVERY mint

package/dist/dom/shadow-registry.js

@@ -65,7 +65,7 @@ function sweep() {
     }
     while (roots.size > MAX_TRACKED_ROOTS) {
         const oldest = roots.values().next();
-        if (oldest.done === true)
+        if (true === oldest.done)
             break;
         roots.delete(oldest.value);
     }
@@ -144,7 +144,7 @@ export function installShadowRegistry() {
     const sweep = (node) => {
         for (const el of node.querySelectorAll('*')) {
             const root = el.shadowRoot;
-            if (root === null)
+            if (null === root)
                 continue;
             record(root, el); // idempotent — a root the patch already caught is skipped inside
             sweep(root);

package/dist/dom/snapshot.js

@@ -20,6 +20,24 @@ const INTERACTIVE = new Set([
     'option',
 ]);
 const SKIP_TAGS = new Set(['script', 'style', 'noscript', 'template', 'head', 'meta', 'link']);
+/** Roles whose whole purpose is announcing a change; both imply an implicit aria-live. */
+const ANNOUNCE_ROLES = new Set(['alert', 'status']);
+/**
+ * Is this element the app SAYING something changed?
+ *
+ * INTERACTIVE mode keeps only actionable elements, which silently drops the one node that explains
+ * why an action did nothing — the error the app just rendered. An agent told to prefer the cheaper
+ * mode was structurally blind to the failure it had caused: the click reports settled with a DOM
+ * mutation, and the lean snapshot shows the same controls as before. Live regions exist precisely
+ * to announce state changes to a consumer that cannot see the screen, which is exactly the agent,
+ * so they are the principled exception — and a bounded one, since a page has very few.
+ */
+function announces(el, role) {
+    if (ANNOUNCE_ROLES.has(role))
+        return true;
+    const live = el.getAttribute('aria-live');
+    return live !== null && 'off' !== live;
+}
 /** Cap on inlined text content so a verbose node can't blow up the snapshot. */
 const TEXT_MAX = 80;
 /**
@@ -31,7 +49,7 @@ const TEXT_MAX = 80;
 function directText(el) {
     let out = '';
     for (const node of el.childNodes) {
-        if (node.nodeType === 3 /* Node.TEXT_NODE */)
+        if (3 === node.nodeType /* Node.TEXT_NODE */)
             out += node.textContent ?? '';
     }
     const collapsed = out.replace(/\s+/g, ' ').trim();
@@ -43,7 +61,7 @@ function skipEarly(el) {
         return true;
     if (isIgnored(el))
         return true; // Reticle overlay + known dev overlays
-    if (el.getAttribute('aria-hidden') === 'true')
+    if ('true' === el.getAttribute('aria-hidden'))
         return true;
     if (el instanceof HTMLElement && el.hidden)
         return true;
@@ -75,13 +93,13 @@ function formatTextLine(depth, text) {
  * snapshot is blind to it; this line makes it visible. Empty for non-container elements.
  */
 function layoutSignature(style) {
-    if (style === null)
+    if (null === style)
         return '';
     const display = style.display;
     // Grid track templates are the high-signal CLS case (column/row count + sizing) and there are
     // few grid containers per page. Flex is intentionally excluded: nearly every row is a flex
     // box, so signing them all floods the snapshot for little regression value.
-    if (display === 'grid' || display === 'inline-grid') {
+    if ('grid' === display || 'inline-grid' === display) {
         const cols = style.gridTemplateColumns;
         return cols !== '' && cols !== 'none' ? `grid-cols:${cols}` : 'grid';
     }
@@ -116,7 +134,7 @@ function pierceChildren(parent) {
     }
     return out;
 }
-function walk(parent, depth, ctx) {
+function walk(parent, depth, ctx, inLive = false) {
     if (depth > ctx.maxDepth)
         return;
     for (const child of pierceChildren(parent)) {
@@ -130,28 +148,31 @@ function walk(parent, depth, ctx) {
         // display-none skip and the layout signature — was two forced style resolutions per node.
         const view = child.ownerDocument.defaultView;
         const style = view !== null ? view.getComputedStyle(child) : null;
-        if (style !== null && style.display === 'none')
+        if (style !== null && 'none' === style.display)
             continue;
         const role = getRole(child);
         const name = getAccessibleName(child);
         const interactive = INTERACTIVE.has(role);
+        // Announcements are exempt from leanness, and so is everything inside one: a live region whose
+        // message sits in a child element would otherwise be included as a contentless `- generic`.
+        const announce = inLive || announces(child, role);
+        const lean = ctx.mode === SnapshotMode.INTERACTIVE && !announce;
         // A generic, unnamed container's own text content — only consulted outside INTERACTIVE mode,
         // so the actionable-only view stays lean while FULL/meaningful views see content regressions.
-        const lean = ctx.mode === SnapshotMode.INTERACTIVE;
-        const text = !lean && role === 'generic' && name.length === 0 ? directText(child) : '';
+        const text = !lean && 'generic' === role && 0 === name.length ? directText(child) : '';
         // Layout signature for grid/flex containers — makes CLS/layout regressions visible.
         const layout = lean ? '' : layoutSignature(style);
         const meaningful = interactive || role !== 'generic' || name.length > 0 || text.length > 0 || layout.length > 0;
         const include = lean ? interactive : meaningful;
         if (include) {
             ctx.nodes += 1;
-            ctx.lines.push(text.length > 0 && name.length === 0 && layout.length === 0
+            ctx.lines.push(text.length > 0 && 0 === name.length && 0 === layout.length
                 ? formatTextLine(depth, text)
                 : formatLine(child, depth, role, name, layout));
-            walk(child, depth + 1, ctx);
+            walk(child, depth + 1, ctx, announce);
         }
         else {
-            walk(child, depth, ctx);
+            walk(child, depth, ctx, announce);
         }
     }
 }

package/dist/dom/source.js

@@ -24,14 +24,14 @@ import { DATA_RETICLE_SOURCE_ATTR } from '@reticlehq/core';
 const SOURCE_ATTR = DATA_RETICLE_SOURCE_ATTR;
 /** Parse a `data-reticle-source="file:line:column"` value into `{ file, line }` (column dropped). */
 export function parseSourceAttr(value) {
-    if (value === null)
+    if (null === value)
         return undefined;
     const m = /^(.*):(\d+):(\d+)$/.exec(value);
-    if (m === null)
+    if (null === m)
         return undefined;
     const file = m[1];
     const line = Number(m[2]);
-    if (file === undefined || file.length === 0 || !Number.isFinite(line))
+    if (file === undefined || 0 === file.length || !Number.isFinite(line))
         return undefined;
     return { file, line };
 }

package/dist/dom/theme.js

@@ -11,12 +11,12 @@
 let cached = null;
 /** Resolve any CSS color string to canonical computed `rgb...)`/`rgba...)`, or null if not a color. */
 function toRgb(value) {
-    if (value.length === 0)
+    if (0 === value.length)
         return null;
     const probe = document.createElement('span');
     probe.style.color = '';
     probe.style.color = value; // invalid colors leave it empty (the setter rejects them)
-    if (probe.style.color === '')
+    if ('' === probe.style.color)
         return null;
     probe.style.position = 'absolute';
     probe.style.pointerEvents = 'none';
@@ -36,7 +36,7 @@ function collectTokens() {
         catch {
             continue;
         }
-        if (rules === null)
+        if (null === rules)
             continue;
         for (const rule of Array.from(rules)) {
             if (!(rule instanceof CSSStyleRule))
@@ -66,15 +66,15 @@ function palette() {
 }
 /** True for a color that carries no visual weight (fully transparent) — never flagged off-theme. */
 function isTransparent(rgb) {
-    return rgb === 'rgba(0, 0, 0, 0)' || rgb === 'transparent';
+    return 'rgba(0, 0, 0, 0)' === rgb || 'transparent' === rgb;
 }
 /** Report an element's theme compliance from its computed style. */
 export function themeReport(cs) {
     const p = palette();
     const colorToken = p.byColor.get(cs.color) ?? null;
     const backgroundToken = p.byColor.get(cs.backgroundColor) ?? null;
-    const colorOff = !isTransparent(cs.color) && colorToken === null;
-    const bgOff = !isTransparent(cs.backgroundColor) && backgroundToken === null;
+    const colorOff = !isTransparent(cs.color) && null === colorToken;
+    const bgOff = !isTransparent(cs.backgroundColor) && null === backgroundToken;
     return {
         colorToken,
         backgroundToken,

package/dist/dom/virtualized.js

@@ -26,7 +26,7 @@ function rowHost(container) {
     let host = container;
     for (let depth = 0; depth < 3; depth += 1) {
         const children = Array.from(host.children).filter((c) => c instanceof HTMLElement);
-        const only = children.length === 1 ? children[0] : undefined;
+        const only = 1 === children.length ? children[0] : undefined;
         if (only === undefined)
             return host;
         // A spacer is a single child that fills (or over-fills) the scroll area.

package/dist/observers/blind-spots.js

@@ -51,10 +51,10 @@ export function countClosedShadowRoots() {
  */
 export function isCrossOriginFrame(frame) {
     const src = frame.getAttribute('src');
-    if (src === null || src.length === 0)
+    if (null === src || 0 === src.length)
         return false;
     try {
-        return frame.contentDocument === null;
+        return null === frame.contentDocument;
     }
     catch {
         return true; // SecurityError on access is itself proof of cross-origin

package/dist/observers/console.js

@@ -12,7 +12,7 @@ const METHOD_EVENT = {
 function stringifyArgs(args) {
     return args
         .map((a) => {
-        if (typeof a === 'string')
+        if ('string' === typeof a)
             return a;
         if (a instanceof Error)
             return a.message;
@@ -23,7 +23,7 @@ function stringifyArgs(args) {
 /** Stacks can be long; cap so a deep async trace never blows the event budget. */
 const MAX_STACK_LEN = TRANSPORT_LIMITS.MAX_STACK_LENGTH;
 function capStack(stack) {
-    if (stack === undefined || stack.length === 0)
+    if (stack === undefined || 0 === stack.length)
         return undefined;
     return stack.length > MAX_STACK_LEN ? stack.slice(0, MAX_STACK_LEN) : stack;
 }
@@ -47,7 +47,7 @@ export function installConsole(emit) {
         const callOriginal = original.bind(console);
         const wrapper = (...args) => {
             // Only console.error carries a stack — the diagnosis case; log/warn stay lean.
-            const stack = method === 'error' ? firstErrorStack(args) : undefined;
+            const stack = 'error' === method ? firstErrorStack(args) : undefined;
             emit(METHOD_EVENT[method], {
                 message: stringifyArgs(args),
                 ...(stack === undefined ? {} : { stack }),

package/dist/observers/dom.js

@@ -9,7 +9,7 @@ import { refs } from '../dom/refs.js';
  */
 function regionKeyOf(target) {
     const el = isElement(target) ? target : null;
-    if (el === null)
+    if (null === el)
         return undefined;
     const labelled = el.closest('[data-testid]');
     return labelled?.getAttribute('data-testid') ?? refs.refFor(el);
@@ -37,7 +37,7 @@ const WATCHED_ATTRS = [
 /** 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 (value === null)
+    if (null === value)
         return undefined;
     return value.length > MAX_ATTR_VALUE_LEN ? `${value.slice(0, MAX_ATTR_VALUE_LEN)}…` : value;
 }
@@ -82,7 +82,7 @@ export function installDom(emit) {
         // (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 (record.type === 'attributes') {
+            if ('attributes' === record.type) {
                 const target = record.target;
                 if (isElement(target) && record.attributeName !== null && !isReticleOverlay(target)) {
                     if (changed >= MAX_PER_BATCH) {
@@ -101,7 +101,7 @@ export function installDom(emit) {
                 }
                 continue;
             }
-            if (record.type === 'characterData') {
+            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;
@@ -158,7 +158,7 @@ export function installDom(emit) {
                 emit(EventType.DOM_ADDED, { role, name, region: regionKeyOf(record.target) }, ref);
                 if (DIALOG_ROLES.has(role) ||
                     LIVE_ROLES.has(role) ||
-                    node.getAttribute('aria-modal') === 'true') {
+                    'true' === node.getAttribute('aria-modal')) {
                     if (isVisible(node))
                         emit(EventType.VISIBLE_SHOWN, { role, name }, ref);
                 }

package/dist/observers/download.d.ts

@@ -1,6 +1,7 @@
 import type { Emit, Teardown } from './types.js';
-export interface DownloadOptions {
+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;
+export {};

package/dist/observers/download.js

@@ -63,7 +63,7 @@ export function installDownload(emit, opts = {}) {
             // 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 (opts.capturePreview === true) {
+            if (true === opts.capturePreview) {
                 const { body, truncated } = projectBody(text.slice(0, PREVIEW_CHARS), record.type);
                 data['preview'] = body;
                 if (truncated)
@@ -79,7 +79,7 @@ export function installDownload(emit, opts = {}) {
     const onClick = (event) => {
         const target = event.target;
         const anchor = target instanceof Element ? target.closest('a[download]') : null;
-        if (anchor === null)
+        if (null === anchor)
             return;
         report(anchor.getAttribute('href') ?? '', anchor.getAttribute('download') ?? undefined);
     };

package/dist/observers/focus.js

@@ -9,7 +9,7 @@ export function focusLabel(el) {
     return name.length > 0 ? `${role} "${name}"` : role;
 }
 function toBody(el) {
-    return el === null || el === document.body;
+    return null === el || el === document.body;
 }
 /**
  * Track element focus movement. Focus dropping to <body> after an act — a modal that closed and stranded

package/dist/observers/frames.js

@@ -32,7 +32,7 @@ export function sameOriginFrameBodies(root) {
             return;
         for (const frame of node.querySelectorAll('iframe')) {
             const body = bodyOf(frame);
-            if (body === null)
+            if (null === body)
                 continue;
             found.push(body);
             walk(body, depth + 1);

package/dist/observers/health.js

@@ -1,4 +1,4 @@
-import { EventType, HealthReason, RETICLE_IPC_GLOBAL, SESSION_HEALTH } from '@reticlehq/core';
+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
@@ -27,12 +27,80 @@ 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,
+    'microsoft edge': BrowserBrand.EDGE,
+    edge: BrowserBrand.EDGE,
+    brave: BrowserBrand.BRAVE,
+    opera: BrowserBrand.OPERA,
+    arc: BrowserBrand.ARC,
+    dia: BrowserBrand.DIA,
+    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;
+        const brands = nav.userAgentData?.brands;
+        if (Array.isArray(brands)) {
+            let chrome;
+            for (const entry of brands) {
+                const name = 'string' === typeof entry?.brand ? entry.brand.toLowerCase() : '';
+                if ('' === name || isFiller(name))
+                    continue;
+                const known = BRAND_BY_NAME[name];
+                if (known === undefined)
+                    continue;
+                if (BrowserBrand.CHROME === known)
+                    chrome = known;
+                else
+                    return known;
+            }
+            return chrome ?? BrowserBrand.OTHER;
+        }
+    }
+    catch {
+        /* a health report must never depend on an exotic userAgentData */
+    }
+    const ua = navigator.userAgent;
+    if (/Edg\//.test(ua))
+        return BrowserBrand.EDGE;
+    if (/OPR\/|Opera/.test(ua))
+        return BrowserBrand.OPERA;
+    if (/Firefox/.test(ua))
+        return BrowserBrand.FIREFOX;
+    if (/Chrome|Chromium/.test(ua))
+        return BrowserBrand.CHROME;
+    if (/Safari/.test(ua))
+        return BrowserBrand.SAFARI;
+    return BrowserBrand.OTHER;
+}
 function snapshotHealth() {
     return {
-        hidden: document.visibilityState === 'hidden',
+        hidden: 'hidden' === document.visibilityState,
         focused: document.hasFocus(),
         runtime: detectRuntime(),
         engine: detectEngine(),
+        brand: detectBrand(),
     };
 }
 /**

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

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

package/dist/observers/ipc.d.ts

@@ -1,10 +1,4 @@
 import type { Emit, Teardown } 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.
- */
-export declare const TAURI_RESPONSE_HEADER_NAME = "Tauri-Response";
 /**
  * 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
@@ -15,8 +9,9 @@ export declare function ipcNetOverrides(url: string, header: (name: string) => s
  * 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.
  */
-export interface IpcOptions {
+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;
+export {};

package/dist/observers/ipc.js

@@ -5,7 +5,7 @@ import { observeSafely } from './types.js';
  * 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.
  */
-export const TAURI_RESPONSE_HEADER_NAME = 'Tauri-Response';
+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' };
@@ -70,7 +70,7 @@ export function installIpc(emit, options = {}) {
     const token = channel.subscribe((record) => {
         observeSafely(() => {
             const url = `${IPC_URL_SCHEME}${record.channel}`;
-            if (record.phase === 'start') {
+            if ('start' === record.phase) {
                 emit(EventType.NET_PENDING, {
                     id: record.id,
                     method: NetInitiator.IPC,
@@ -83,18 +83,18 @@ export function installIpc(emit, options = {}) {
             // 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 = record.oneWay === true && record.ok === undefined;
+            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 = record.ok === true;
+            const ok = true === record.ok;
             emit(EventType.NET_REQUEST, {
                 id: record.id,
                 method: NetInitiator.IPC,
                 url,
                 ...(verdictless ? {} : { ok, status: ok ? IpcStatus.OK : IpcStatus.ERROR }),
-                ...(record.oneWay === true ? { oneWay: true } : {}),
+                ...(true === record.oneWay ? { oneWay: true } : {}),
                 durationMs: record.durationMs ?? 0,
                 initiator: NetInitiator.IPC,
                 ...(record.error === undefined ? {} : { error: record.error }),
@@ -102,11 +102,11 @@ export function installIpc(emit, options = {}) {
                 // 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 }),
-                ...(options.captureBodies === true
+                ...(true === options.captureBodies
                     ? {
                         ...(record.requestBody === undefined ? {} : { requestBody: record.requestBody }),
                         ...(record.responseBody === undefined ? {} : { responseBody: record.responseBody }),
-                        ...(record.responseBodyTruncated === true ? { responseBodyTruncated: true } : {}),
+                        ...(true === record.responseBodyTruncated ? { responseBodyTruncated: true } : {}),
                     }
                     : {}),
             });

package/dist/observers/network-body.js

@@ -45,7 +45,7 @@ const ENDLESS_BY_DESIGN = /event-stream/i;
 export function isStreamingBody(contentType, contentLength) {
     if (contentType !== null && ENDLESS_BY_DESIGN.test(contentType))
         return false;
-    return contentLength === null;
+    return null === contentLength;
 }
 /**
  * Longest the SDK will wait on a response-body clone before emitting without it.
@@ -84,7 +84,7 @@ export async function withBodyDeadline(read) {
     }
 }
 export function isCapturableType(contentType) {
-    if (contentType === null)
+    if (null === contentType)
         return false;
     if (STREAMING_CONTENT.test(contentType))
         return false;