@reticlehq/browser 3.1.0 → 3.3.0

package/dist/actions/actions-dom.d.ts

@@ -4,11 +4,12 @@ interface ClickGeometry {
     scrolledIntoView: boolean;
 }
 export declare const NO_GEOMETRY: ClickGeometry;
+export declare function mouseEventFor(el: Element, type: string, init?: MouseEventInit): MouseEvent;
 export declare function fireClickSequence(el: HTMLElement, hold?: {
     ms: number;
     sleep: (ms: number) => Promise<void>;
     now: () => number;
-}): Promise<{
+}, detail?: number): Promise<{
     prevented: boolean;
     heldMs: number;
 }>;

package/dist/actions/actions-dom.js

@@ -7,11 +7,21 @@ export const NO_GEOMETRY = {
     occludedBy: null,
     scrolledIntoView: false,
 };
-export async function fireClickSequence(el, hold) {
+export function mouseEventFor(el, type, init = {}) {
+    return new MouseEvent(type, { ...init, view: el.ownerDocument.defaultView });
+}
+function pointerEventFor(el, type, init) {
+    const full = { ...init, view: el.ownerDocument.defaultView };
+    return 'function' === typeof PointerEvent
+        ? new PointerEvent(type, full)
+        : new MouseEvent(type, full);
+}
+export async function fireClickSequence(el, hold, detail) {
     const doc = el.ownerDocument;
     const from = doc.activeElement ?? doc.body;
+    const init = { bubbles: true, cancelable: true, detail: detail ?? 0 };
     firePointer(el, 'pointerdown', from);
-    asSyntheticInput(() => el.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true })));
+    asSyntheticInput(() => el.dispatchEvent(mouseEventFor(el, 'mousedown', init)));
     if (el.tabIndex >= 0 && 'function' === typeof el.focus)
         el.focus();
     let heldMs = 0;
@@ -21,8 +31,8 @@ export async function fireClickSequence(el, hold) {
         heldMs = hold.now() - startedAt;
     }
     firePointer(el, 'pointerup', from);
-    asSyntheticInput(() => el.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true })));
-    const notPrevented = asSyntheticInput(() => el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })));
+    asSyntheticInput(() => el.dispatchEvent(mouseEventFor(el, 'mouseup', init)));
+    const notPrevented = asSyntheticInput(() => el.dispatchEvent(mouseEventFor(el, 'click', init)));
     return { prevented: !notPrevented, heldMs };
 }
 function isMeasurable(rect) {
@@ -57,24 +67,10 @@ export function clickGeometry(el) {
     return { ...hitTest(el, rect), scrolledIntoView };
 }
 export function firePointer(el, type, relatedTarget = null) {
-    asSyntheticInput(() => {
-        if ('function' === typeof PointerEvent) {
-            el.dispatchEvent(new PointerEvent(type, { bubbles: true, cancelable: true, relatedTarget }));
-        }
-        else {
-            el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, relatedTarget }));
-        }
-    });
+    asSyntheticInput(() => el.dispatchEvent(pointerEventFor(el, type, { bubbles: true, cancelable: true, relatedTarget })));
 }
 export function firePointerNonBubbling(el, type, relatedTarget = null) {
-    asSyntheticInput(() => {
-        if ('function' === typeof PointerEvent) {
-            el.dispatchEvent(new PointerEvent(type, { bubbles: false, cancelable: true, relatedTarget }));
-        }
-        else {
-            el.dispatchEvent(new MouseEvent(type, { bubbles: false, cancelable: true, relatedTarget }));
-        }
-    });
+    asSyntheticInput(() => el.dispatchEvent(pointerEventFor(el, type, { bubbles: false, cancelable: true, relatedTarget })));
 }
 function makeDataTransfer(data) {
     if (typeof DataTransfer !== 'function')
@@ -117,12 +113,9 @@ export async function dragElement(source, target, data) {
             button: 0,
             ...(related !== undefined ? { relatedTarget: related } : {}),
         };
-        if ('function' === typeof PointerEvent && type.startsWith('pointer')) {
-            el.dispatchEvent(new PointerEvent(type, { ...init, pointerId: 1, isPrimary: true }));
-        }
-        else {
-            el.dispatchEvent(new MouseEvent(type, init));
-        }
+        el.dispatchEvent(type.startsWith('pointer')
+            ? pointerEventFor(el, type, { ...init, pointerId: 1, isPrimary: true })
+            : mouseEventFor(el, type, init));
     };
     const sourceRect = source.getBoundingClientRect();
     const destRect = target !== null ? dest.getBoundingClientRect() : null;
@@ -190,24 +183,18 @@ export async function fireTapSequence(el, hold) {
     }
     asSyntheticInput(() => el.dispatchEvent(makeTouchEvent('touchend', [])));
     firePointerTouch(el, 'pointerup');
-    const clicked = asSyntheticInput(() => el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })));
+    const clicked = asSyntheticInput(() => el.dispatchEvent(mouseEventFor(el, 'click', { bubbles: true, cancelable: true })));
     return { prevented: !clicked, heldMs };
 }
 function firePointerTouch(el, type) {
-    asSyntheticInput(() => {
-        if ('function' === typeof PointerEvent) {
-            el.dispatchEvent(new PointerEvent(type, {
-                bubbles: true,
-                cancelable: true,
-                pointerType: 'touch',
-                isPrimary: true,
-                width: 23,
-                height: 23,
-            }));
-            return;
-        }
-        el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true }));
-    });
+    asSyntheticInput(() => el.dispatchEvent(pointerEventFor(el, type, {
+        bubbles: true,
+        cancelable: true,
+        pointerType: 'touch',
+        isPrimary: true,
+        width: 23,
+        height: 23,
+    })));
 }
 function touchListFor(el) {
     if ('function' !== typeof Touch || 'function' !== typeof el.getBoundingClientRect)

package/dist/actions/actions.d.ts

@@ -34,7 +34,6 @@ interface ActionResult {
     };
     warning?: string;
 }
-export declare const MAX_HOLD_MS = 30000;
 export declare const ZOOM_NEEDS_REAL_BROWSER_MSG: string;
 export declare function executeAction(ref: string, action: string, args?: Record<string, unknown>): Promise<ActionResult>;
 export declare function dispatchWebMcp(tool: string, params: Record<string, unknown>, confirmDangerous?: boolean): Promise<unknown>;

package/dist/actions/actions.js

@@ -124,7 +124,7 @@ function assertActionAllowed(el, action, args) {
         throw new Error(`potentially destructive action blocked; retry with args.${DANGEROUS_ACTION_CONFIRM_ARG}=true`);
     }
 }
-import { NO_GEOMETRY, fireClickSequence, fireTapSequence, clickGeometry, firePointer, firePointerNonBubbling, dragElement, } from './actions-dom.js';
+import { NO_GEOMETRY, fireClickSequence, fireTapSequence, clickGeometry, firePointer, firePointerNonBubbling, dragElement, mouseEventFor, } from './actions-dom.js';
 import { scrollFrom } from './scroll.js';
 function enabledOf(el) {
     return !getStates(el).includes(ElementState.DISABLED);
@@ -141,7 +141,7 @@ function activeRef(el) {
         return null;
     return refs.refFor(active);
 }
-export const MAX_HOLD_MS = 30_000;
+const MAX_HOLD_MS = 30_000;
 function clampHold(raw) {
     if ('number' !== typeof raw || !Number.isFinite(raw) || raw <= 0)
         return 0;
@@ -167,16 +167,18 @@ function asFiniteNumber(raw) {
 async function dispatchOther(el, action, args) {
     switch (action) {
         case ActionType.DBLCLICK:
-            return !asSyntheticInput(() => el.dispatchEvent(new MouseEvent('dblclick', { bubbles: true, cancelable: true })));
+            await fireClickSequence(el, undefined, 1);
+            await fireClickSequence(el, undefined, 2);
+            return !asSyntheticInput(() => el.dispatchEvent(mouseEventFor(el, 'dblclick', { bubbles: true, cancelable: true, detail: 2 })));
         case ActionType.HOVER: {
             const doc = el.ownerDocument;
             const from = doc.activeElement ?? doc.body;
             firePointer(el, 'pointerover', from);
-            el.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, relatedTarget: from }));
+            el.dispatchEvent(mouseEventFor(el, 'mouseover', { bubbles: true, relatedTarget: from }));
             firePointerNonBubbling(el, 'pointerenter', from);
-            el.dispatchEvent(new MouseEvent('mouseenter', { relatedTarget: from }));
+            el.dispatchEvent(mouseEventFor(el, 'mouseenter', { relatedTarget: from }));
             firePointer(el, 'pointermove', from);
-            const moved = el.dispatchEvent(new MouseEvent('mousemove', { bubbles: true, cancelable: true }));
+            const moved = el.dispatchEvent(mouseEventFor(el, 'mousemove', { bubbles: true, cancelable: true }));
             const holdMs = clampHold(args['holdMs']);
             if (holdMs > 0)
                 await sleep(holdMs);
@@ -252,7 +254,11 @@ async function dispatchOther(el, action, args) {
             }
             if (alreadyAtCheckedState(el, action))
                 return false;
-            const event = new MouseEvent('click', { bubbles: true, cancelable: true, composed: true });
+            const event = mouseEventFor(el, 'click', {
+                bubbles: true,
+                cancelable: true,
+                composed: true,
+            });
             const notPrevented = asSyntheticInput(() => el.dispatchEvent(event));
             return !notPrevented || event.defaultPrevented;
         }

package/dist/actions/value-input.js

@@ -13,12 +13,21 @@ export function setNativeValue(el, value) {
     el.dispatchEvent(new Event('change', { bubbles: true }));
     return !notPrevented;
 }
-export function assertNotRichText(el, action) {
+function isRichText(el) {
     const flag = el.getAttribute('contenteditable');
-    if (el.isContentEditable || (flag !== null && flag !== 'false')) {
-        throw new Error(`cannot ${action} a contenteditable element — rich-text editors keep their own document model, ` +
-            'so writing to the DOM here would look right and submit the old content. This surface is not supported yet.');
-    }
+    if (el.isContentEditable || (null !== flag && 'false' !== flag))
+        return true;
+    if ('textbox' === el.getAttribute('role'))
+        return true;
+    if (!('editContext' in el))
+        return false;
+    const surface = el;
+    return null !== surface.editContext && undefined !== surface.editContext;
+}
+export function assertNotRichText(el, action) {
+    if (!isRichText(el))
+        return;
+    throw new Error(`cannot ${action} a contenteditable or EditContext editor; use press or an input`);
 }
 export function assertEditable(el, action) {
     if (el.disabled) {

package/dist/connect-options.d.ts

@@ -8,6 +8,7 @@ export interface ReticleConnectOptions {
     allowInProduction?: boolean;
     overlay?: boolean;
     captureNetworkBodies?: boolean;
+    networkBodyMaxChars?: number;
     sourceMapping?: boolean;
     captureErrorBodies?: boolean;
     exposePresenter?: boolean;

package/dist/dom/addressing/source.d.ts

@@ -1,4 +1,4 @@
-export interface SourceLocation {
+interface SourceLocation {
     file: string;
     line: number;
 }
@@ -7,3 +7,4 @@ export declare function sourceFromDom(el: Element): SourceLocation | undefined;
 export declare function sourceFor(el: Element, adapterSource: SourceLocation | undefined): SourceLocation | undefined;
 export declare function documentHasSourceStamps(doc: Document): boolean;
 export declare function formatSource(source: SourceLocation | undefined): string | undefined;
+export {};

package/dist/dom/dom-ignore.d.ts

@@ -5,3 +5,4 @@ export declare function setIgnoreSelectors(selectors: string[]): void;
 export declare function isReticleOverlay(el: Element): boolean;
 export declare function isReticleUi(node: Element | null): boolean;
 export declare function isIgnored(el: Element): boolean;
+export declare function appModalOpen(doc: Document): boolean;

package/dist/dom/dom-ignore.js

@@ -22,3 +22,16 @@ export function isIgnored(el) {
     const sel = [ours, DEV_OVERLAYS, extraIgnore].filter((part) => part.length > 0).join(',');
     return el.closest(sel) !== null;
 }
+const APP_MODAL = 'dialog[open], [aria-modal="true"]';
+export function appModalOpen(doc) {
+    for (const el of Array.from(doc.querySelectorAll(APP_MODAL))) {
+        if (el.closest(RETICLE_OVERLAY) !== null)
+            continue;
+        if (el instanceof HTMLElement && (el.hidden || null !== el.closest('[hidden]')))
+            continue;
+        if (el instanceof HTMLElement && 'none' === getComputedStyle(el).display)
+            continue;
+        return true;
+    }
+    return false;
+}

package/dist/dom/query.js

@@ -1,5 +1,5 @@
 import { DATA_RETICLE_SOURCE_ATTR, ElementState, QueryBy, REDACTED_VALUE, TRANSPORT_LIMITS, } from '@reticlehq/core';
-import { isFrame, isHtmlElement, isInput, isSelect, isTextArea } from './realm.js';
+import { isElement, isFrame, isHtmlElement, isInput, isSelect, isTextArea } from './realm.js';
 import { capturedRootOf } from './shadow-registry.js';
 import { getAccessibleName, getRole, describe, getStates, isInViewport, isVisible, } from './a11y.js';
 import { isIgnored, isReticleOverlay } from './dom-ignore.js';
@@ -27,20 +27,35 @@ function fuzzyVisibleText(actual, expected) {
 function exactVisibleText(actual, expected) {
     return normaliseVisibleText(actual) === normaliseVisibleText(expected);
 }
+const NON_RENDERED_TAGS = ['script', 'style', 'template', 'noscript'];
+function isNonRendered(el) {
+    return NON_RENDERED_TAGS.includes(el.tagName.toLowerCase());
+}
 function directText(el) {
     if (isInput(el)) {
         const type = el.type.toLowerCase();
         if ('submit' === type || 'button' === type || 'reset' === type)
             return el.value;
     }
-    const tag = el.tagName.toLowerCase();
-    if ('script' === tag || 'style' === tag)
+    if (isNonRendered(el))
         return '';
     return Array.from(el.childNodes)
         .filter((node) => Node.TEXT_NODE === node.nodeType)
         .map((node) => node.textContent ?? '')
         .join('');
 }
+function visibleTextOf(el, memo) {
+    if (isNonRendered(el) || isIgnored(el) || !isVisible(el, memo))
+        return '';
+    let text = '';
+    for (const node of Array.from(el.childNodes)) {
+        if (Node.TEXT_NODE === node.nodeType)
+            text += node.textContent ?? '';
+        else if (isElement(node))
+            text += visibleTextOf(node, memo);
+    }
+    return text;
+}
 function semanticNameTarget(el) {
     if (isInput(el) || isTextArea(el) || isSelect(el))
         return true;
@@ -205,7 +220,8 @@ function findCandidates(query) {
     if (true === query.self) {
         if (query.scope === undefined)
             return { candidates: [], scopeMissing };
-        if (query.text !== undefined && !fuzzyVisibleText(container.textContent ?? '', query.text)) {
+        if (query.text !== undefined &&
+            !fuzzyVisibleText(visibleTextOf(container, new Map()), query.text)) {
             return { candidates: [], scopeMissing };
         }
         return { candidates: isIgnored(container) ? [] : [container], scopeMissing };
@@ -342,10 +358,11 @@ function buildPresentRegions(query) {
 function splitTextOwner(container, wanted) {
     let best;
     let bestDepth = -1;
+    const memo = new Map();
     for (const el of elementsUnder(container)) {
         if (isIgnored(el))
             continue;
-        if (!fuzzyVisibleText(el.textContent ?? '', wanted))
+        if (!fuzzyVisibleText(visibleTextOf(el, memo), wanted))
             continue;
         let depth = 0;
         for (let parent = el.parentElement; parent !== null; parent = parent.parentElement)
@@ -392,15 +409,16 @@ function buildEmptyHint(query) {
     const container = resolveContainer(query.scope).container ?? document.body;
     const all = container.querySelectorAll(`[${TESTID_ATTR}]`);
     const present = [];
+    const seen = new Set();
     for (const el of Array.from(all)) {
         if (isIgnored(el))
             continue;
         const id = el.getAttribute(TESTID_ATTR);
-        if (id !== null && id.length > 0 && !present.includes(id)) {
+        if (null === id || 0 === id.length || seen.has(id))
+            continue;
+        seen.add(id);
+        if (present.length < MAX_PRESENT_TESTIDS)
             present.push(id);
-            if (present.length >= MAX_PRESENT_TESTIDS)
-                break;
-        }
     }
     const registered = declaredTestids();
     const knownEmptyState = present.some((id) => registered.includes(id));
@@ -408,6 +426,7 @@ function buildEmptyHint(query) {
     const hint = {
         route,
         presentTestids: present,
+        ...(seen.size > present.length ? { presentTestidsTotal: seen.size } : {}),
         presentRegions: buildPresentRegions(query),
         knownEmptyState,
     };

package/dist/dom/snapshot.d.ts

@@ -5,7 +5,7 @@ interface SnapshotStatus {
     visibleDialogs?: string[];
     overlayHidingPage?: string;
 }
-export interface SnapshotResult {
+interface SnapshotResult {
     tree: string;
     status: SnapshotStatus;
     nodes: number;

package/dist/observers/console.js

@@ -2,6 +2,9 @@ import { EventType, TRANSPORT_LIMITS } from '@reticlehq/core';
 import { observeSafely } from './types.js';
 import { safeStringify } from '../security/serialization.js';
 import { requireCapturedMethod } from '../util/captured-method.js';
+import { createRepeatLimiter } from './error-repeats.js';
+const CSP_VIOLATION_EVENT = 'securitypolicyviolation';
+const REPORT_ONLY = 'report';
 const METHOD_EVENT = {
     log: EventType.CONSOLE_LOG,
     warn: EventType.CONSOLE_WARN,
@@ -54,6 +57,16 @@ export function installConsole(emit) {
         patched.set(method, wrapper);
         console[method] = wrapper;
     }
+    const repeats = createRepeatLimiter();
+    const emitError = (payload) => {
+        const decision = repeats.admit(payload);
+        if (!decision.emit)
+            return;
+        emit(EventType.ERROR_UNCAUGHT, {
+            ...payload,
+            ...(undefined === decision.repeats ? {} : { repeats: decision.repeats }),
+        });
+    };
     const onError = (event) => {
         if (!(event instanceof ErrorEvent)) {
             const target = event.target;
@@ -62,43 +75,55 @@ export function installConsole(emit) {
             const tag = target.tagName.toLowerCase();
             const url = target.getAttribute('src') ?? target.getAttribute('href') ?? '';
             observeSafely(() => {
-                emit(EventType.ERROR_UNCAUGHT, {
-                    message: `<${tag}> failed to load${0 === url.length ? '' : `: ${url}`}`,
-                    kind: 'resource',
-                    ...(0 === url.length ? {} : { source: url }),
-                });
+                const message = `<${tag}> failed to load${0 === url.length ? '' : `: ${url}`}`;
+                emitError({ message, kind: 'resource', ...(0 === url.length ? {} : { source: url }) });
             });
             return;
         }
         observeSafely(() => {
             const stack = capStack(event.error instanceof Error ? event.error.stack : undefined);
-            emit(EventType.ERROR_UNCAUGHT, {
+            const payload = {
                 message: event.message,
                 source: event.filename,
                 line: event.lineno,
                 ...(stack === undefined ? {} : { stack }),
-            });
+            };
+            emitError(payload);
         });
     };
     const onRejection = (event) => {
         observeSafely(() => {
             const reason = event.reason;
             const stack = capStack(reason instanceof Error ? reason.stack : undefined);
-            emit(EventType.ERROR_UNCAUGHT, {
+            const payload = {
                 message: reason instanceof Error ? reason.message : String(reason),
                 kind: 'unhandledrejection',
                 ...(stack === undefined ? {} : { stack }),
-            });
+            };
+            emitError(payload);
+        });
+    };
+    const onViolation = (event) => {
+        const what = 0 === event.blockedURI.length ? 'inline content' : event.blockedURI;
+        const reportOnly = REPORT_ONLY === event.disposition;
+        emit(reportOnly ? EventType.CONSOLE_WARN : EventType.CONSOLE_ERROR, {
+            message: reportOnly
+                ? `[Report Only] Content Security Policy directive: ${event.violatedDirective} would block ${what}`
+                : `Content Security Policy directive: ${event.violatedDirective} blocked ${what}`,
+            kind: CSP_VIOLATION_EVENT,
+            ...(0 === event.blockedURI.length ? {} : { source: event.blockedURI }),
         });
     };
-    window.addEventListener('error', onError, true);
-    window.addEventListener('unhandledrejection', onRejection);
+    const listeners = new AbortController();
+    const { signal } = listeners;
+    window.addEventListener('error', onError, { capture: true, signal });
+    window.addEventListener('unhandledrejection', onRejection, { signal });
+    window.addEventListener(CSP_VIOLATION_EVENT, onViolation, { capture: true, signal });
     return () => {
         for (const [method, original] of originals) {
             if (console[method] === patched.get(method))
                 console[method] = original;
         }
-        window.removeEventListener('error', onError, true);
-        window.removeEventListener('unhandledrejection', onRejection);
+        listeners.abort();
     };
 }

package/dist/observers/departure.js

@@ -35,15 +35,23 @@ export function installDeparture(emit) {
                 return;
             const href = anchor.getAttribute('href') ?? '';
             const here = document.location.href;
-            if (!isDeparture(href, anchor.hasAttribute('download'), here))
+            const download = anchor.hasAttribute('download');
+            if (!isDeparture(href, download, here))
                 return;
-            seq += 1;
-            emit(EventType.NET_PENDING, {
-                id: `nav-${String(seq)}`,
-                method: 'GET',
-                url: new URL(href, here).toString(),
-                initiator: NetInitiator.NAVIGATION,
-                ...(anchor.hasAttribute('download') ? { download: true } : {}),
+            const url = new URL(href, here).toString();
+            queueMicrotask(() => {
+                observeSafely(() => {
+                    if (event.defaultPrevented)
+                        return;
+                    seq += 1;
+                    emit(EventType.NET_PENDING, {
+                        id: `nav-${String(seq)}`,
+                        method: 'GET',
+                        url,
+                        initiator: NetInitiator.NAVIGATION,
+                        ...(download ? { download: true } : {}),
+                    });
+                });
             });
         });
     };

package/dist/observers/dom.js

@@ -153,8 +153,10 @@ export function installDom(emit) {
                     dropped += 1;
                     continue;
                 }
-                if (isReticleOverlay(node))
+                if (isReticleOverlay(node) ||
+                    (isElement(record.target) && isReticleOverlay(record.target))) {
                     continue;
+                }
                 const gone = describeMount(node);
                 if (gone === undefined)
                     continue;

package/dist/observers/download.js

@@ -7,6 +7,7 @@ const PREVIEW_CHARS = 2000;
 export function installDownload(emit, opts = {}) {
     if (typeof URL.createObjectURL !== 'function')
         return () => undefined;
+    const ac = new AbortController();
     const objectUrl = URL.createObjectURL.bind(URL);
     const known = new Map();
     const originalCreate = captureMethod(URL, 'createObjectURL');
@@ -58,7 +59,7 @@ export function installDownload(emit, opts = {}) {
             report(anchor.getAttribute('href') ?? '', anchor.getAttribute('download') ?? undefined);
         });
     };
-    document.addEventListener('click', onClick, true);
+    document.addEventListener('click', onClick, { capture: true, signal: ac.signal });
     const originalClick = captureMethod(HTMLAnchorElement.prototype, 'click');
     const patchedClick = function reticleObservedAnchorClick() {
         const pending = observeValue(() => this.hasAttribute('download')
@@ -75,7 +76,7 @@ export function installDownload(emit, opts = {}) {
     };
     HTMLAnchorElement.prototype.click = patchedClick;
     return () => {
-        document.removeEventListener('click', onClick, true);
+        ac.abort();
         if (URL.createObjectURL === patchedCreate)
             URL.createObjectURL = originalCreate;
         if (HTMLAnchorElement.prototype.click === patchedClick) {

package/dist/observers/error-repeats.d.ts

@@ -0,0 +1,18 @@
+export declare const REPEAT_BURST = 3;
+export declare const MAX_TRACKED_FINGERPRINTS = 256;
+export interface RepeatDecision {
+    readonly emit: boolean;
+    readonly repeats?: number;
+}
+export interface ErrorIdentity {
+    readonly message: string;
+    readonly source?: string;
+    readonly line?: number;
+    readonly kind?: string;
+    readonly stack?: string;
+}
+export declare function fingerprintError(identity: ErrorIdentity): string;
+export interface RepeatLimiter {
+    admit(identity: ErrorIdentity): RepeatDecision;
+}
+export declare function createRepeatLimiter(burst?: number, maxTracked?: number): RepeatLimiter;

package/dist/observers/error-repeats.js

@@ -0,0 +1,41 @@
+import { fnv1a } from '@reticlehq/core';
+export const REPEAT_BURST = 3;
+export const MAX_TRACKED_FINGERPRINTS = 256;
+const PASS = { emit: true };
+const DROP = { emit: false };
+function isCheckpoint(count) {
+    if (count < 10)
+        return false;
+    let n = count;
+    while (0 === n % 10)
+        n /= 10;
+    return 1 === n;
+}
+export function fingerprintError(identity) {
+    return fnv1a([
+        identity.message,
+        identity.source ?? '',
+        undefined === identity.line ? '' : String(identity.line),
+        identity.kind ?? '',
+        identity.stack ?? '',
+    ].join('\x00'));
+}
+export function createRepeatLimiter(burst = REPEAT_BURST, maxTracked = MAX_TRACKED_FINGERPRINTS) {
+    const counts = new Map();
+    return {
+        admit(identity) {
+            const key = fingerprintError(identity);
+            const seen = (counts.get(key) ?? 0) + 1;
+            counts.delete(key);
+            if (counts.size >= maxTracked) {
+                const oldest = counts.keys().next();
+                if (!(oldest.done ?? false))
+                    counts.delete(oldest.value);
+            }
+            counts.set(key, seen);
+            if (seen <= burst)
+                return PASS;
+            return isCheckpoint(seen) ? { emit: true, repeats: seen } : DROP;
+        },
+    };
+}

package/dist/observers/field.d.ts

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