@reticlehq/browser 2.13.1 → 3.1.0

package/dist/observers/perf.d.ts

@@ -1,12 +1,2 @@
 import type { Emit, Teardown } from './types.js';
-/**
- * Observe the web-perf signals a screenshot tool fundamentally cannot verify — largest-contentful-paint
- * (LCP), cumulative layout shift (CLS), and long tasks — and emit them into the ring buffer so an agent
- * can assert "no layout shift on load" or "LCP under 2.5s". No-ops when PerformanceObserver or a given
- * entry type is unavailable (jsdom / older browsers), so it never throws in an unsupported context.
- *
- * Each event carries `at` (the entry's own startTime) so a consumer can reason about WHEN the metric
- * occurred rather than when it was flushed — buffered:true replays pre-install entries, whose emit time
- * would otherwise be install time.
- */
 export declare function installPerf(emit: Emit): Teardown;

package/dist/observers/perf.js

@@ -1,14 +1,4 @@
 import { EventType, PerfMetric } from '@reticlehq/core';
-/**
- * Observe the web-perf signals a screenshot tool fundamentally cannot verify — largest-contentful-paint
- * (LCP), cumulative layout shift (CLS), and long tasks — and emit them into the ring buffer so an agent
- * can assert "no layout shift on load" or "LCP under 2.5s". No-ops when PerformanceObserver or a given
- * entry type is unavailable (jsdom / older browsers), so it never throws in an unsupported context.
- *
- * Each event carries `at` (the entry's own startTime) so a consumer can reason about WHEN the metric
- * occurred rather than when it was flushed — buffered:true replays pre-install entries, whose emit time
- * would otherwise be install time.
- */
 export function installPerf(emit) {
     if (typeof PerformanceObserver !== 'function')
         return () => undefined;
@@ -23,14 +13,9 @@ export function installPerf(emit) {
             observers.push(po);
         }
         catch {
-            /* entry type unsupported in this browser — skip it, leave the others installed */
         }
     };
-    // CLS is CUMULATIVE: sum qualifying shifts and report the running total, not each isolated shift.
-    // ponytail: naive running sum — no session-windowing (5s window / 1s gap); enough for
-    // "no layout shift on load" and trend, upgrade to windowed sessions if a CWV-exact number is needed.
     let cls = 0;
-    // LCP only grows across candidates — surface a value only when it exceeds the last, not every candidate.
     let lcp = 0;
     observe('largest-contentful-paint', (e) => {
         const value = Math.round(e.startTime);
@@ -41,7 +26,6 @@ export function installPerf(emit) {
     });
     observe('layout-shift', (e) => {
         const ls = e;
-        // Shifts within 500ms of a user input are expected (not CLS) — the spec's hadRecentInput flag.
         if (true === ls.hadRecentInput)
             return;
         cls += ls.value ?? 0;

package/dist/observers/route.d.ts

@@ -1,3 +1,2 @@
-import type { Emit, Teardown } from './types.js';
-/** Patch the History API + listen to popstate/hashchange to emit route.change. */
+import { type Emit, type Teardown } from './types.js';
 export declare function installRoute(emit: Emit): Teardown;

package/dist/observers/route.js

@@ -1,4 +1,5 @@
 import { EventType } from '@reticlehq/core';
+import { observeSafely } from './types.js';
 import { captureMethod } from '../patching/capture-method.js';
 function snapshotLocation() {
     return {
@@ -8,29 +9,25 @@ function snapshotLocation() {
         href: location.href,
     };
 }
-/** Patch the History API + listen to popstate/hashchange to emit route.change. */
 export function installRoute(emit) {
-    // Keep the true originals for teardown identity; bound copies are used for invocation
-    // (History methods throw "Illegal invocation" if called with the wrong `this`).
     const origPush = captureMethod(history, 'pushState');
     const origReplace = captureMethod(history, 'replaceState');
     const callPush = origPush.bind(history);
     const callReplace = origReplace.bind(history);
-    // The `from` baseline for the NEXT popstate/hashchange. Updated in fire on every emitted change
-    // — including pushState/replaceState — so a later Back nav isn't compared against a stale href
-    // (which made `to === from` trip and silently drop the back navigation).
     let lastHref = location.href;
     const fire = (from) => {
-        const to = snapshotLocation();
-        if (to.href === from)
-            return;
-        lastHref = to.href;
-        emit(EventType.ROUTE_CHANGE, {
-            from,
-            to: to.href,
-            pathname: to.pathname,
-            search: to.search,
-            hash: to.hash,
+        observeSafely(() => {
+            const to = snapshotLocation();
+            if (to.href === from)
+                return;
+            lastHref = to.href;
+            emit(EventType.ROUTE_CHANGE, {
+                from,
+                to: to.href,
+                pathname: to.pathname,
+                search: to.search,
+                hash: to.hash,
+            });
         });
     };
     const patchedPush = (data, unused, url) => {
@@ -51,9 +48,6 @@ export function installRoute(emit) {
     window.addEventListener('popstate', onNav);
     window.addEventListener('hashchange', onNav);
     return () => {
-        // Restore ONLY if the slot still holds our wrapper. If a router/analytics SDK wrapped
-        // history.pushState AFTER connect(), unconditionally writing origPush back would silently
-        // uninstall THEIR instrumentation too — the SDK harming the app it only meant to observe.
         if (history.pushState === patchedPush)
             history.pushState = origPush;
         if (history.replaceState === patchedReplace)

package/dist/observers/scroll.d.ts

@@ -1,3 +1,2 @@
 import type { Emit, Teardown } from './types.js';
-/** Observe scroll position + reveal-on-scroll for modern scroll-reactive UIs. */
 export declare function installScroll(emit: Emit): Teardown;

package/dist/observers/scroll.js

@@ -1,9 +1,8 @@
 import { EventType, ScrollDirection } from '@reticlehq/core';
-import { refs } from '../dom/refs.js';
-import { nativeSetTimeout, nativeClearTimeout } from '../timers/native-timers.js';
+import { refs } from '../dom/addressing/refs.js';
+import { nativeSetTimeout, nativeClearTimeout } from '../timers/native/native-timers.js';
 const THROTTLE_MS = 100;
 const REVEAL_SELECTOR = '[data-reticle-reveal], [data-reveal], section';
-/** Observe scroll position + reveal-on-scroll for modern scroll-reactive UIs. */
 export function installScroll(emit) {
     const ac = new AbortController();
     const { signal } = ac;
@@ -32,8 +31,6 @@ export function installScroll(emit) {
             emitPosition();
             return;
         }
-        // Leading-edge only dropped the FINAL, resting position — an agent asserting "scrolled to the
-        // footer" saw the last mid-scroll sample, not where the page settled. Schedule a trailing emit.
         if (trailingTimer === undefined) {
             trailingTimer = nativeSetTimeout(() => {
                 trailingTimer = undefined;
@@ -52,12 +49,6 @@ export function installScroll(emit) {
             }
         }, { threshold: 0.25 });
         const observer = io;
-        // Observe reveal targets present at install. Reveal-on-scroll sections are in the initial DOM by
-        // design (they exist hidden and animate in on scroll), so this covers the real case. Watching the
-        // whole body subtree for LATE-mounted reveal targets was tried and reverted: a second body-wide
-        // MutationObserver on EVERY app — running querySelectorAll(section,...) per mutation batch — is
-        // disproportionate overhead for a niche signal. Dynamically-mounted reveal targets are simply not
-        // tracked (an honest blind spot, consistent with the rest of the SDK).
         for (const el of document.querySelectorAll(REVEAL_SELECTOR))
             observer.observe(el);
     }

package/dist/observers/sdk-failure.d.ts

@@ -1,9 +1,4 @@
 import type { Emit } from './types.js';
-/**
- * Where in the SDK a failure happened. A fixed vocabulary of OUR module names — never a file path,
- * never anything derived from the user's app — so the field stays low-cardinality and non-identifying
- * while still telling a maintainer which subsystem to open.
- */
 export declare const SdkSite: {
     readonly CONNECT: "connect";
     readonly DOM_OBSERVER: "dom_observer";
@@ -19,10 +14,7 @@ export declare const SdkSite: {
     readonly COMMAND: "command";
     readonly RECORDER: "recorder";
     readonly TRANSPORT: "transport";
+    readonly TEARDOWN: "teardown";
 };
 export type SdkSite = (typeof SdkSite)[keyof typeof SdkSite];
-/**
- * Report that a piece of the SDK failed. Never throws, and never prevents the caller from doing what
- * it was going to do anyway (which is almost always: carry on degraded).
- */
 export declare function reportSdkFailure(emit: Emit, site: SdkSite, error: unknown): void;

package/dist/observers/sdk-failure.js

@@ -1,28 +1,4 @@
-/**
- * The SDK reporting its OWN failures.
- *
- * Half of Reticle runs inside the page, and that half was completely silent. Every `catch` in the SDK
- * swallows by design — correctly, because an instrumentation layer must never break the app it
- * observes — but the consequence was that an observer throwing on page load just produced a quieter
- * product. No error, no signal, no way to know. A user would report "Reticle doesn't see my network
- * calls" and there would be nothing on our side to look at.
- *
- * Two properties make this safe to add:
- *
- *   1. IT MAKES NO NETWORK REQUEST. The report rides the bridge WebSocket the SDK is already connected
- *      to — localhost, the same channel every other event uses. The published promise that the SDK
- *      talks only to a local bridge stays exactly true, and the daemon decides what (if anything) goes
- *      anywhere else. Adding an outbound call from inside someone's app would have been a different
- *      product with a different privacy posture.
- *   2. IT CANNOT BREAK THE APP. Reporting is wrapped in its own try/catch and is strictly additive to
- *      an existing `catch` block. A failure to report a failure is discarded.
- */
 import { EventType } from '@reticlehq/core';
-/**
- * Where in the SDK a failure happened. A fixed vocabulary of OUR module names — never a file path,
- * never anything derived from the user's app — so the field stays low-cardinality and non-identifying
- * while still telling a maintainer which subsystem to open.
- */
 export const SdkSite = {
     CONNECT: 'connect',
     DOM_OBSERVER: 'dom_observer',
@@ -38,13 +14,9 @@ export const SdkSite = {
     COMMAND: 'command',
     RECORDER: 'recorder',
     TRANSPORT: 'transport',
+    TEARDOWN: 'teardown',
 };
-/** Cap the message here too — the server strips variables, but an unbounded string is a bad idea twice. */
 const MAX_MESSAGE = 500;
-/**
- * Report that a piece of the SDK failed. Never throws, and never prevents the caller from doing what
- * it was going to do anyway (which is almost always: carry on degraded).
- */
 export function reportSdkFailure(emit, site, error) {
     try {
         const message = error instanceof Error ? error.message : String(error);
@@ -55,6 +27,5 @@ export function reportSdkFailure(emit, site, error) {
         });
     }
     catch {
-        /* a failure report must never become a second failure */
     }
 }

package/dist/observers/state.d.ts

@@ -1,19 +1,9 @@
-import type { Emit, Teardown } from './types.js';
+import { type Emit, type Teardown } from './types.js';
 interface StateChange {
     path: string;
     old: unknown;
     new: unknown;
 }
-/**
- * Shallow top-level diff of two store states — the keys whose value changed. Immutable updates
- * (Zustand/Redux) replace the changed key's reference, so `Object.is` catches them. Pure; deep-nested
- * diffing behind an unchanged top-level reference is a v2 concern.
- */
 export declare function diffState(prev: unknown, next: unknown): StateChange[];
-/**
- * Subscribe to every registered store that exposed a subscribe method, emitting a STATE_CHANGE per
- * changed top-level path with {name, path, old, new} — automatic diffs, not pull-only readings. Stores
- * without a subscribe fall back to the pull path (reticle_state). Fully reversible.
- */
 export declare function installStoreState(emit: Emit): Teardown;
 export {};

package/dist/observers/state.js

@@ -1,14 +1,10 @@
 import { BlindSpotKind, EventType, REDACTED_VALUE } from '@reticlehq/core';
 import { subscribableStores, onStoreRegistered, } from '../registry/stores.js';
 import { isSensitiveKey, sanitizeForTransport } from '../security/serialization.js';
+import { observeSafely } from './types.js';
 function isRecord(value) {
     return 'object' === typeof value && value !== null && !Array.isArray(value);
 }
-/**
- * Shallow top-level diff of two store states — the keys whose value changed. Immutable updates
- * (Zustand/Redux) replace the changed key's reference, so `Object.is` catches them. Pure; deep-nested
- * diffing behind an unchanged top-level reference is a v2 concern.
- */
 export function diffState(prev, next) {
     if (!isRecord(prev) || !isRecord(next)) {
         return Object.is(prev, next) ? [] : [{ path: '', old: prev, new: next }];
@@ -20,7 +16,6 @@ export function diffState(prev, next) {
     }
     return changes;
 }
-/** Redact a changed value when its path is credential-bearing, else cap it for transport. */
 function project(path, value) {
     return isSensitiveKey(path) ? REDACTED_VALUE : sanitizeForTransport(value);
 }
@@ -32,60 +27,38 @@ function safeRead(getter) {
         return undefined;
     }
 }
-/**
- * Subscribe to every registered store that exposed a subscribe method, emitting a STATE_CHANGE per
- * changed top-level path with {name, path, old, new} — automatic diffs, not pull-only readings. Stores
- * without a subscribe fall back to the pull path (reticle_state). Fully reversible.
- */
 export function installStoreState(emit) {
     const active = new Map();
     const watch = ([name, getter, subscribe]) => {
-        // A re-registration under the same name is the HMR cycle: the store INSTANCE is replaced (new
-        // getter + new subscribe). Skipping it (the old `seen` guard) left the subscription bound to the
-        // DEAD getter forever and the live store invisible until a full reload. Rebind: drop the previous
-        // subscription for this name, then subscribe the new tuple. Guard the old unsubscribe — if it throws
-        // (a misbehaving store), the rebind must still proceed, or the live store stays invisible.
         try {
             active.get(name)?.();
         }
         catch {
-            /* a faulty unsubscribe must not block re-binding to the new instance */
         }
         let last = safeRead(getter);
         active.set(name, subscribe(() => {
-            const next = safeRead(getter);
-            for (const change of diffState(last, next)) {
-                emit(EventType.STATE_CHANGE, {
-                    name,
-                    path: change.path,
-                    value: project(change.path, change.new),
-                    old: project(change.path, change.old),
-                });
-            }
-            last = next;
+            observeSafely(() => {
+                const next = safeRead(getter);
+                for (const change of diffState(last, next)) {
+                    emit(EventType.STATE_CHANGE, {
+                        name,
+                        path: change.path,
+                        value: project(change.path, change.new),
+                        old: project(change.path, change.old),
+                    });
+                }
+                last = next;
+            });
         }));
     };
-    // Stores already registered...
     for (const entry of subscribableStores())
         watch(entry);
-    /**
-     * Declare an unwatched state channel — and clear it the moment one is watched.
-     *
-     * With nothing subscribed, every act reports `stateDiffs: []`, which reads as "the app changed no
-     * state" when the truth is "nobody was looking". Emitted as a BLIND_SPOT so it travels the path
-     * that already exists for everything the layer cannot see: bounding, never impeaching, so no
-     * verdict turns UNKNOWN over it.
-     */
     if (0 === active.size) {
         emit(EventType.BLIND_SPOT, { kind: BlindSpotKind.UNWATCHED_STATE, count: 1 });
     }
-    //...and any registered LATER. The SDK installs observers during connect, but apps call
-    // registerStore after that, so without this the common case subscribes to nothing.
     const offRegistered = onStoreRegistered((entry) => {
         const wasDark = 0 === active.size;
         watch(entry);
-        // The channel just lit up. A blind spot that is never withdrawn is a permanent lie, and this one
-        // is withdrawn in the ordinary case: apps register their stores AFTER connect() installs us.
         if (wasDark && active.size > 0) {
             emit(EventType.BLIND_SPOT, { kind: BlindSpotKind.UNWATCHED_STATE, count: 0 });
         }
@@ -97,7 +70,6 @@ export function installStoreState(emit) {
                 unsubscribe();
             }
             catch {
-                /* one faulty store unsubscribe must not abort tearing the rest down */
             }
         }
         active.clear();

package/dist/observers/storage.d.ts

@@ -1,22 +1,8 @@
 import { type Emit, type Teardown } from './types.js';
-/** The three readable client-side storage areas. httpOnly cookies are invisible to JS by design. */
 export interface StorageSnapshot {
     local: Record<string, string>;
     session: Record<string, string>;
     cookies: Record<string, string>;
 }
-/**
- * Read client-side storage on demand (the STORAGE_READ command). Powers `reticle_storage` — the
- * agent verifies "token persisted after login", "cart survived reload", "logout cleared the session"
- * from the app's real storage rather than inferring it from the DOM. `area` scopes to one area; omit
- * for all three. Sensitive keys are redacted; httpOnly cookies are unreadable by design (documented).
- */
 export declare function readStorage(area?: string): StorageSnapshot | Record<string, string>;
-/**
- * Observe storage WRITES (not just reads): patch Storage.setItem/removeItem so a token persisted, a
- * cart updated, or a session cleared emits a STORAGE_CHANGE {area, key, old?, new?} diff — the "before"
- * the pull path can never see. localStorage and sessionStorage share one prototype, so `this` inside the
- * patch identifies the area. The native originals are read off the prototype descriptor (not a bare
- * method access) and re-dispatched via `.call(this)`. Fully reversible; values redacted like the reads.
- */
 export declare function installStorage(emit: Emit): Teardown;

package/dist/observers/storage.js

@@ -1,7 +1,6 @@
 import { EventType, REDACTED_VALUE, StorageArea } from '@reticlehq/core';
-import { isSensitiveKey } from '../security/serialization.js';
+import { isSensitiveKey, scrubKnownSecrets } from '../security/serialization.js';
 import { observeSafely, observeValue } from './types.js';
-/** Accessing localStorage/sessionStorage throws in a sandboxed iframe / disabled-storage context. */
 function safeArea(get) {
     try {
         return get();
@@ -18,15 +17,13 @@ function readArea(storage) {
         const key = storage.key(i);
         if (null === key)
             continue;
-        // Redact credential-bearing keys (token/session/password/…) so auth state never leaks verbatim.
-        out[key] = isSensitiveKey(key) ? REDACTED_VALUE : (storage.getItem(key) ?? '');
+        const val = storage.getItem(key) ?? '';
+        out[key] = isSensitiveKey(key) ? REDACTED_VALUE : scrubKnownSecrets(val);
     }
     return out;
 }
 function readCookies() {
     const out = {};
-    // Reading document.cookie can throw (SecurityError) in a sandboxed / cookie-disabled context — guard
-    // it the same way safeArea guards localStorage, so one bad area never crashes the whole STORAGE read.
     let raw = '';
     try {
         raw = typeof document !== 'undefined' ? document.cookie : '';
@@ -45,21 +42,17 @@ function readCookies() {
             out[key] = REDACTED_VALUE;
             continue;
         }
+        let val = '';
         try {
-            out[key] = decodeURIComponent(part.slice(eq + 1).trim());
+            val = decodeURIComponent(part.slice(eq + 1).trim());
         }
         catch {
-            out[key] = part.slice(eq + 1).trim();
+            val = part.slice(eq + 1).trim();
         }
+        out[key] = scrubKnownSecrets(val);
     }
     return out;
 }
-/**
- * Read client-side storage on demand (the STORAGE_READ command). Powers `reticle_storage` — the
- * agent verifies "token persisted after login", "cart survived reload", "logout cleared the session"
- * from the app's real storage rather than inferring it from the DOM. `area` scopes to one area; omit
- * for all three. Sensitive keys are redacted; httpOnly cookies are unreadable by design (documented).
- */
 export function readStorage(area) {
     if (area === StorageArea.LOCAL)
         return readArea(safeArea(() => window.localStorage));
@@ -73,19 +66,11 @@ export function readStorage(area) {
         cookies: readCookies(),
     };
 }
-/** Redact a value when its key is credential-bearing — the same rule the pull path applies. */
 function redactFor(key, value) {
     if (null === value)
         return undefined;
-    return isSensitiveKey(key) ? REDACTED_VALUE : value;
+    return isSensitiveKey(key) ? REDACTED_VALUE : scrubKnownSecrets(value);
 }
-/**
- * Observe storage WRITES (not just reads): patch Storage.setItem/removeItem so a token persisted, a
- * cart updated, or a session cleared emits a STORAGE_CHANGE {area, key, old?, new?} diff — the "before"
- * the pull path can never see. localStorage and sessionStorage share one prototype, so `this` inside the
- * patch identifies the area. The native originals are read off the prototype descriptor (not a bare
- * method access) and re-dispatched via `.call(this)`. Fully reversible; values redacted like the reads.
- */
 export function installStorage(emit) {
     if ('undefined' === typeof Storage)
         return () => undefined;
@@ -96,9 +81,6 @@ export function installStorage(emit) {
     if (origSet === undefined || origRemove === undefined || origClear === undefined) {
         return () => undefined;
     }
-    // Resolve sessionStorage at CALL time, not once at install. If the property threw during install
-    // (a transient sandbox state) the captured reference would be null and every session write would be
-    // misreported as `local` for the life of the page. Reads are cheap and safeArea swallows throws.
     const areaOf = (storage) => storage === safeArea(() => window.sessionStorage) ? StorageArea.SESSION : StorageArea.LOCAL;
     const readOld = (storage, key) => {
         try {
@@ -109,9 +91,10 @@ export function installStorage(emit) {
         }
     };
     const patchedSetItem = function (key, value) {
-        // The app's write happens FIRST and outside the guard — it must succeed or fail on its own terms.
         const old = observeValue(() => readOld(this, key)) ?? null;
         origSet.call(this, key, value);
+        if (old === value)
+            return;
         observeSafely(() => {
             emit(EventType.STORAGE_CHANGE, {
                 area: areaOf(this),
@@ -126,7 +109,6 @@ export function installStorage(emit) {
         const old = observeValue(() => readOld(this, key)) ?? null;
         origRemove.call(this, key);
         observeSafely(() => {
-            // No `new` field ⇒ the key was removed.
             emit(EventType.STORAGE_CHANGE, {
                 area: areaOf(this),
                 key,
@@ -136,9 +118,6 @@ export function installStorage(emit) {
     };
     proto.removeItem = patchedRemoveItem;
     const patchedClear = function () {
-        // localStorage.clear() is the most common logout — but it emitted NOTHING, so "logout cleared the
-        // session" was unverifiable from the write path. Snapshot the keys BEFORE clearing (the values are
-        // gone after), then report each as a removal, reusing the {area, key, old} shape removeItem emits.
         const area = areaOf(this);
         const removed = [];
         try {
@@ -149,7 +128,6 @@ export function installStorage(emit) {
             }
         }
         catch {
-            // Enumerating keys can throw in a locked-down context; clear anyway, just without the diff.
         }
         origClear.call(this);
         for (const { key, old } of removed) {
@@ -164,8 +142,6 @@ export function installStorage(emit) {
     };
     proto.clear = patchedClear;
     return () => {
-        // Restore only if the slot still holds our wrapper — never uninstall a wrapper the app layered
-        // on top of ours after connect().
         if (proto.setItem === patchedSetItem)
             proto.setItem = origSet;
         if (proto.removeItem === patchedRemoveItem)

package/dist/observers/types.d.ts

@@ -1,20 +1,5 @@
 import type { EventType } from '@reticlehq/core';
-/** An observer emits normalized events; the orchestrator stamps time + forwards them. */
 export type Emit = (type: EventType, data: Record<string, unknown>, ref?: string) => void;
-/** Every observer returns a teardown that fully restores any patched globals. */
 export type Teardown = () => void;
-/**
- * Run an observation so it can never escape into the app's call stack.
- *
- * Every monkey-patch calls its observation INSIDE the function it replaced, so a throw does not surface
- * as an SDK error — it propagates out of `localStorage.setItem` after the write already succeeded, out
- * of `history.pushState` (crashing a router's navigate), or out of `console.log` before the message
- * reaches the console. Guarding the transport hop alone is not enough: the payload is BUILT here too
- * (reading the old value, resolving the area, redacting), and any of that can throw on a hostile or
- * exotic object.
- *
- * A dev-only observability SDK must never be able to break the app it is observing.
- */
 export declare function observeSafely(observation: () => void): void;
-/** Like observeSafely, but for reading a value the observation needs; undefined if the read throws. */
 export declare function observeValue<T>(read: () => T): T | undefined;

package/dist/observers/types.js

@@ -1,24 +1,10 @@
-/**
- * Run an observation so it can never escape into the app's call stack.
- *
- * Every monkey-patch calls its observation INSIDE the function it replaced, so a throw does not surface
- * as an SDK error — it propagates out of `localStorage.setItem` after the write already succeeded, out
- * of `history.pushState` (crashing a router's navigate), or out of `console.log` before the message
- * reaches the console. Guarding the transport hop alone is not enough: the payload is BUILT here too
- * (reading the old value, resolving the area, redacting), and any of that can throw on a hostile or
- * exotic object.
- *
- * A dev-only observability SDK must never be able to break the app it is observing.
- */
 export function observeSafely(observation) {
     try {
         observation();
     }
     catch {
-        /* observation is best-effort; the host app's control flow is not */
     }
 }
-/** Like observeSafely, but for reading a value the observation needs; undefined if the read throws. */
 export function observeValue(read) {
     try {
         return read();

package/dist/patching/capture-method.d.ts

@@ -1,26 +1,2 @@
-/**
- * Capture a method off an object so it can be restored — or re-invoked via `.call` — later.
- *
- * Monkeypatching is unavoidable in this SDK: observing history, console, fetch and XHR means
- * replacing a method and putting the original back on teardown. Putting it back requires holding the
- * UNBOUND original, because identity is what teardown compares — a bound copy is a different function
- * and would leave the patch installed forever.
- *
- * `@typescript-eslint/unbound-method` exists to catch the common mistake this pattern deliberately
- * makes, so every such site used to carry an eslint-disable. Disabling a rule seven times to express
- * one intention is worse than naming the intention once: those disables also suppressed the rule for
- * any OTHER unbound access on the same lines, which is exactly what the rule is for.
- *
- * The generic index access here is not something the rule flags, so callers stay clean and the
- * "I meant to do this" is stated in one place instead of seven.
- */
 export declare function captureMethod<T, K extends keyof T>(target: T, key: K): T[K];
-/**
- * The `value` setter defined on a prototype, for inputs whose value must be set the way the browser
- * does it — React installs its own descriptor, and assigning `el.value` directly skips the tracker it
- * relies on to notice a change.
- *
- * Same reason as `captureMethod` for existing separately from its call site: a property descriptor's
- * `set` is an unbound function, and naming that intention once beats disabling the rule at each use.
- */
 export declare function captureValueSetter(proto: object): ((this: HTMLElement, value: string) => void) | undefined;

package/dist/patching/capture-method.js

@@ -1,36 +1,10 @@
-/**
- * Capture a method off an object so it can be restored — or re-invoked via `.call` — later.
- *
- * Monkeypatching is unavoidable in this SDK: observing history, console, fetch and XHR means
- * replacing a method and putting the original back on teardown. Putting it back requires holding the
- * UNBOUND original, because identity is what teardown compares — a bound copy is a different function
- * and would leave the patch installed forever.
- *
- * `@typescript-eslint/unbound-method` exists to catch the common mistake this pattern deliberately
- * makes, so every such site used to carry an eslint-disable. Disabling a rule seven times to express
- * one intention is worse than naming the intention once: those disables also suppressed the rule for
- * any OTHER unbound access on the same lines, which is exactly what the rule is for.
- *
- * The generic index access here is not something the rule flags, so callers stay clean and the
- * "I meant to do this" is stated in one place instead of seven.
- */
 export function captureMethod(target, key) {
     return target[key];
 }
-/**
- * The `value` setter defined on a prototype, for inputs whose value must be set the way the browser
- * does it — React installs its own descriptor, and assigning `el.value` directly skips the tracker it
- * relies on to notice a change.
- *
- * Same reason as `captureMethod` for existing separately from its call site: a property descriptor's
- * `set` is an unbound function, and naming that intention once beats disabling the rule at each use.
- */
 export function captureValueSetter(proto) {
     const descriptor = Object.getOwnPropertyDescriptor(proto, 'value');
     if (descriptor === undefined)
         return undefined;
-    // Read through the same generic index access `captureMethod` uses: reaching for `.set` directly is
-    // what the rule flags, and it is right to in general — this is the one place that means it.
     const setter = captureMethod(descriptor, 'set');
     return setter;
 }

package/dist/presenter/chrome/layers.d.ts

@@ -0,0 +1,2 @@
+export declare const Z_OVERLAY = 2147483600;
+export declare const Z_TOUR: number;

package/dist/presenter/chrome/layers.js

@@ -0,0 +1,2 @@
+export const Z_OVERLAY = 2147483600;
+export const Z_TOUR = Z_OVERLAY + 30;

package/dist/presenter/chrome/log-kinds.d.ts

@@ -0,0 +1,12 @@
+export declare const LOG_KIND: {
+    readonly READ: "read";
+    readonly ACT: "act";
+    readonly NARRATION: "narration";
+    readonly HUMAN: "human";
+};
+export type LogKind = (typeof LOG_KIND)[keyof typeof LOG_KIND];
+export declare const LOG_RESULT: {
+    readonly PASS: "pass";
+    readonly FAIL: "fail";
+};
+export type LogResult = (typeof LOG_RESULT)[keyof typeof LOG_RESULT];

package/dist/presenter/chrome/log-kinds.js

@@ -0,0 +1,7 @@
+export const LOG_KIND = {
+    READ: 'read',
+    ACT: 'act',
+    NARRATION: 'narration',
+    HUMAN: 'human',
+};
+export const LOG_RESULT = { PASS: 'pass', FAIL: 'fail' };