@reticlehq/browser 2.3.0 → 2.5.0

package/dist/dom/blind-spots.js

@@ -10,7 +10,7 @@ export function classifyCrossOriginFrames(frames) {
 }
 /** Probe the live document: count iframes whose document is unreachable (cross-origin). */
 export function countCrossOriginFrames() {
-    if (typeof document === 'undefined')
+    if ('undefined' === typeof document)
         return 0;
     const frames = [];
     for (const frame of document.querySelectorAll('iframe')) {

package/dist/dom/chart.js

@@ -54,12 +54,12 @@ export function hasNonFiniteCoordinate(value) {
 /** True when the geometry encloses no area — no coordinates, or every coordinate pair identical. */
 export function isDegenerate(value) {
     const nums = geometryNumbers(value).filter((n) => Number.isFinite(n));
-    if (nums.length === 0)
+    if (0 === nums.length)
         return true;
     // A polyline of one repeated point draws nothing. Compare pairs, not raw numbers, so a legitimately
     // flat line (varying x, constant y) is NOT flagged — that is a real chart of constant data.
-    const xs = nums.filter((_, i) => i % 2 === 0);
-    const ys = nums.filter((_, i) => i % 2 === 1);
+    const xs = nums.filter((_, i) => 0 === i % 2);
+    const ys = nums.filter((_, i) => 1 === i % 2);
     const allSame = (arr) => arr.every((v) => v === arr[0]);
     return xs.length > 1 && allSame(xs) && allSame(ys);
 }
@@ -74,14 +74,14 @@ export function inspectChart(root) {
         for (const el of Array.from(root.querySelectorAll(tag))) {
             for (const attr of GEOMETRY_ATTRS) {
                 const value = el.getAttribute(attr);
-                if (value === null)
+                if (null === value)
                     continue;
                 examined += 1;
                 const sample = value.length > SAMPLE_MAX ? `${value.slice(0, SAMPLE_MAX)}…` : value;
                 if (hasNonFiniteCoordinate(value)) {
                     findings.push({ kind: 'non-finite-coordinates', tag, attr, sample });
                 }
-                else if (value.trim().length === 0) {
+                else if (0 === value.trim().length) {
                     findings.push({ kind: 'empty-geometry', tag, attr, sample });
                 }
                 else if (isDegenerate(value)) {

package/dist/dom/desktop-capture.d.ts

@@ -20,7 +20,7 @@
  * (`reticle-tauri`). Absent that, this returns `{ ok: false }` and the tool reports no-provider
  * rather than guessing.
  */
-export interface CaptureResult {
+interface CaptureResult {
     ok: boolean;
     /**
      * Filesystem path of the captured PNG, written by the desktop shell.
@@ -34,3 +34,4 @@ export interface CaptureResult {
     reason?: string;
 }
 export declare function captureDesktopWindow(fullPage?: boolean): Promise<CaptureResult>;
+export {};

package/dist/dom/desktop-capture.js

@@ -48,8 +48,8 @@ function tauriCapture() {
         return undefined;
     const invoke = internals.invoke.bind(internals);
     return async (fullPage) => {
-        const path = await invoke(RETICLE_TAURI_CAPTURE_COMMAND, { fullPage: fullPage === true });
-        return typeof path === 'string' ? path : null;
+        const path = await invoke(RETICLE_TAURI_CAPTURE_COMMAND, { fullPage: true === fullPage });
+        return 'string' === typeof path ? path : null;
     };
 }
 /**
@@ -94,13 +94,13 @@ async function withReticleUiHidden(capture) {
 }
 export async function captureDesktopWindow(fullPage = false) {
     const channel = window[RETICLE_IPC_GLOBAL];
-    const capture = typeof channel?.capture === 'function' ? channel.capture : tauriCapture();
+    const capture = 'function' === typeof channel?.capture ? channel.capture : tauriCapture();
     if (capture === undefined) {
         return { ok: false, reason: 'no desktop capture helper installed' };
     }
     try {
         const path = await withReticleUiHidden(() => capture(fullPage));
-        return typeof path === 'string' && path.length > 0
+        return 'string' === typeof path && path.length > 0
             ? { ok: true, path }
             : { ok: false, reason: 'capture returned no image' };
     }

package/dist/dom/occlusion.js

@@ -7,13 +7,13 @@ import { isReticleUi } from './dom-ignore.js';
  * we never false-positive an occlusion. Reticle's own HUD is never treated as an occluder.
  */
 export function hitTestOccluder(el, rect) {
-    if (rect.width === 0 || rect.height === 0)
+    if (0 === rect.width || 0 === rect.height)
         return null;
     const doc = el.ownerDocument;
     if (typeof doc.elementFromPoint !== 'function')
         return null;
     const top = doc.elementFromPoint(rect.left + rect.width / 2, rect.top + rect.height / 2);
-    if (top === null || isReticleUi(top))
+    if (null === top || isReticleUi(top))
         return null;
     const lands = top === el || el.contains(top) || top.contains(el);
     return lands ? null : top;

package/dist/dom/query.js

@@ -106,7 +106,13 @@ function findIn(container, query) {
                 // value is the component name;.source (if present) still takes precedence inside.
                 return findByComponent(container, { ...query, component: query.component ?? value });
             default:
-                return [];
+                // THROW, never `return []`. An unsupported strategy answering "no matches" is
+                // indistinguishable from the element genuinely being absent, so `by:'css'` — the first thing
+                // anyone arriving from Playwright reaches for — reported a page with a <body> as empty. The
+                // server now rejects unknown strategies at the schema; this is the same guarantee for every
+                // other path in (replay, reticle_run, an internal caller), because a false negative invented
+                // by the tool is the exact failure this product exists to prevent.
+                throw new Error(`unsupported query strategy '${String(by)}' — use one of: ${Object.values(QueryBy).join(', ')}`);
         }
     }
     // Auto-anchor (component / source) — checked before the role/text fields so a query carrying
@@ -184,7 +190,7 @@ function embeddedRootsUnder(root) {
             if (!isFrame(el))
                 continue;
             const body = readableFrameBody(el);
-            if (body === null)
+            if (null === body)
                 continue; // cross-origin — declared, not searched
             found.push(body);
             walk(body, depth + 1);
@@ -218,7 +224,7 @@ function findCandidates(query) {
     const { container, scopeMissing } = resolveContainer(query.scope);
     // A given-but-missing scope searches NOTHING — never the whole page. The empty result plus the
     // scopeMissing flag is what keeps "gone scope" distinct from "absent element".
-    if (container === null)
+    if (null === container)
         return { candidates: [], scopeMissing: true };
     const seen = new Set();
     const out = [];
@@ -259,7 +265,7 @@ function projectAttrs(el, keys) {
     const out = {};
     for (const key of keys.slice(0, ATTR_KEYS_MAX)) {
         const raw = el.getAttribute(key);
-        if (raw === null)
+        if (null === raw)
             continue;
         out[key] = isSensitiveKey(key) ? REDACTED_VALUE : raw.slice(0, ATTR_VALUE_MAX);
     }
@@ -286,16 +292,15 @@ const MAX_DESCRIBED = TRANSPORT_LIMITS.MAX_COLLECTION_ITEMS;
  * "how many?" stay exact while the answer stays affordable.
  */
 export function matchQuery(query, state, limit = MAX_DESCRIBED) {
-    let elements;
-    let scopeMissing = false;
-    try {
-        const found = findCandidates(query);
-        elements = found.candidates;
-        scopeMissing = found.scopeMissing;
-    }
-    catch {
-        elements = [];
-    }
+    // NO blanket try/catch here. It used to turn ANY exception during candidate-finding into
+    // `elements = []`, which is the same lie as the `default` arm above: a query that could not run
+    // reported that the element is not on the page. The one failure it was plausibly guarding —
+    // a scope selector that matches nothing — is already handled explicitly and distinctly, as
+    // `scopeMissing`, so what remained was a net that could only convert real faults into false
+    // negatives.
+    const found = findCandidates(query);
+    const elements = found.candidates;
+    const scopeMissing = found.scopeMissing;
     // One visibility cache for the whole (synchronous) query pass. isVisible is an O(depth) forced-style
     // walk; the state filter runs it over EVERY candidate (the count must be exact) — on a match-heavy
     // page (e.g. a 3k-row grid) that is tens of thousands of getComputedStyle calls on the host's main
@@ -306,7 +311,7 @@ export function matchQuery(query, state, limit = MAX_DESCRIBED) {
     const described = filtered.slice(0, Math.max(0, Math.min(limit, MAX_DESCRIBED)));
     const descriptors = described.map((el) => {
         const base = describe(el, visMemo);
-        if (attrs === undefined || attrs.length === 0)
+        if (attrs === undefined || 0 === attrs.length)
             return base;
         const projected = projectAttrs(el, attrs);
         return projected === undefined ? base : { ...base, attrs: projected };
@@ -316,13 +321,18 @@ export function matchQuery(query, state, limit = MAX_DESCRIBED) {
         count: filtered.length,
         elements: descriptors,
         ...(scopeMissing ? { scopeMissing: true } : {}),
+        // On a MISS, carry the same diagnosis `runQuery` has always returned. MATCH is the command every
+        // PREDICATE uses, so without this a failed assertion was a dead end ("no element matched") while
+        // the identical failure through reticle_query listed the testids that ARE present. Computed only
+        // when there is nothing to report, so the hot path pays nothing.
+        ...(0 === filtered.length ? { hint: buildEmptyHint(query) } : {}),
     };
 }
 /** Resolve `aria-labelledby` (one or more element IDs) to the referenced elements' text — a bare ID is
  * not a human-readable name. Undefined when unset or nothing resolves. */
 function resolveLabelledBy(el) {
     const ids = el.getAttribute('aria-labelledby');
-    if (ids === null)
+    if (null === ids)
         return undefined;
     const text = ids
         .split(/\s+/)
@@ -426,8 +436,8 @@ function buildEmptyHint(query) {
  */
 export function runQuery(query, limit) {
     const result = matchQuery(query, undefined, limit);
-    const scopeFields = result.scopeMissing === true ? { scopeMissing: true } : {};
-    if (result.elements.length === 0) {
+    const scopeFields = true === result.scopeMissing ? { scopeMissing: true } : {};
+    if (0 === result.elements.length) {
         return {
             elements: result.elements,
             count: result.count,

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

@@ -31,7 +31,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 +43,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 +75,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';
     }
@@ -130,7 +130,7 @@ 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);
@@ -138,14 +138,14 @@ function walk(parent, depth, ctx) {
         // 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);

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/index.d.ts

@@ -8,9 +8,9 @@ export { registerAdapter, identifyComponent, readComponentState, elementHasHover
 export type { ReticleAdapter, ComponentInfo, ComponentSource } from './registry/adapters.js';
 export { registerStore, unregisterStore, storeNames, readStores, readStoresWithTruncation, } from './registry/stores.js';
 export type { StoreGetter, StoreLike, StoreSubscribe } from './registry/stores.js';
-export { tanstackQueryStore, jotaiStore, xstateStore, valtioStore, mobxStore, pushStore, } from './registry/store-adapters.js';
-export type { QuerySnapshot } from './registry/store-adapters.js';
-export { registerCapabilities, getCapabilities, hasCapabilities } from './registry/capabilities.js';
+export { tanstackQueryStore, jotaiStore, xstateStore, valtioStore, mobxStore, recoilStore, svelteStore, piniaStore, pushStore, } from './registry/store-adapters.js';
+export type { QuerySnapshot, RecoilAtomSnapshot } from './registry/store-adapters.js';
+export { registerCapabilities, getCapabilities, hasCapabilities, setCapabilitiesListener, } from './registry/capabilities.js';
 export type { Capabilities, CapabilitiesInput, CapabilityFlow } from './registry/capabilities.js';
 export { createReticleEmitter } from './registry/emitter.js';
 export type { ReticleEmitter, EmitterTarget, CreateReticleEmitterOptions, } from './registry/emitter.js';

package/dist/index.js

@@ -18,9 +18,9 @@ export { registerStore, unregisterStore, storeNames, readStores, readStoresWithT
 // Adapters for state libraries that do not natively expose `{getState, subscribe}`. zustand and Redux
 // need none of these; TanStack Query is the one that matters most, because a stale-cache bug fires no
 // request and renders a plausible value, so the cache is the only witness.
-export { tanstackQueryStore, jotaiStore, xstateStore, valtioStore, mobxStore, pushStore, } from './registry/store-adapters.js';
+export { tanstackQueryStore, jotaiStore, xstateStore, valtioStore, mobxStore, recoilStore, svelteStore, piniaStore, pushStore, } from './registry/store-adapters.js';
 // Capability registry: the app self-describes its testable surface via reticle.describe.
-export { registerCapabilities, getCapabilities, hasCapabilities } from './registry/capabilities.js';
+export { registerCapabilities, getCapabilities, hasCapabilities, setCapabilitiesListener, } from './registry/capabilities.js';
 // SDK helpers: adopt the recommended integration patterns without boilerplate.
 export { createReticleEmitter } from './registry/emitter.js';
 export { commitAndSignal } from './registry/commit-and-signal.js';

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);