@reticlehq/browser 2.4.0 → 2.6.0

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

@@ -10,7 +10,14 @@ export declare const NO_GEOMETRY: ClickGeometry;
  * `defaultPrevented` so the probe is unchanged. Focus only moves for focusable targets (tabIndex>=0),
  * so a plain <div> click still reports focusMoved=null.
  */
-export declare function fireClickSequence(el: HTMLElement): boolean;
+export declare function fireClickSequence(el: HTMLElement, hold?: {
+    ms: number;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+}): Promise<{
+    prevented: boolean;
+    heldMs: number;
+}>;
 /**
  * Click-like geometry honesty: scroll an off-viewport target into view, then hit-test the click
  * point. Synthetic dispatch always reaches the target regardless — this is purely so the agent

package/dist/actions/actions-dom.js

@@ -12,17 +12,31 @@ export const NO_GEOMETRY = {
  * `defaultPrevented` so the probe is unchanged. Focus only moves for focusable targets (tabIndex>=0),
  * so a plain <div> click still reports focusMoved=null.
  */
-export function fireClickSequence(el) {
+export async function fireClickSequence(el, hold) {
     const doc = el.ownerDocument;
     const from = doc.activeElement ?? doc.body;
     firePointer(el, 'pointerdown', from);
     el.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
-    if (el.tabIndex >= 0 && typeof el.focus === 'function')
+    if (el.tabIndex >= 0 && 'function' === typeof el.focus)
         el.focus();
+    // The gap that makes hold-to-confirm driveable. Everything between down and up used to be
+    // synchronous, so a control whose contract is "the button is down for N ms" could not be
+    // expressed at all — the reported case cancelled its own confirm on the mouseup that arrived 7ms
+    // later. `drag` already splits the pair across a gap; this is that shape with a timer.
+    //
+    // The ACHIEVED hold is measured and returned rather than echoed back: `holdMs: 1200` against a
+    // 1200ms animation is a race by construction, and a caller needs to tell "held 1200" from
+    // "held 1204". A backgrounded tab throttles timers, so this can legitimately overshoot by a lot.
+    let heldMs = 0;
+    if (hold !== undefined && hold.ms > 0) {
+        const startedAt = hold.now();
+        await hold.sleep(hold.ms);
+        heldMs = hold.now() - startedAt;
+    }
     firePointer(el, 'pointerup', from);
     el.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));
     const notPrevented = el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
-    return !notPrevented;
+    return { prevented: !notPrevented, heldMs };
 }
 /** A box has layout we can reason about (jsdom returns an all-zero box — nothing to hit-test). */
 function isMeasurable(rect) {
@@ -31,7 +45,7 @@ function isMeasurable(rect) {
 /** The center of `rect` falls outside the visible viewport. */
 function isOffViewport(el, rect) {
     const win = el.ownerDocument.defaultView;
-    if (win === null)
+    if (null === win)
         return false;
     const cx = rect.left + rect.width / 2;
     const cy = rect.top + rect.height / 2;
@@ -40,7 +54,7 @@ function isOffViewport(el, rect) {
 /** Hit-test the center: occluded iff the top NON-Reticle element is a foreign subtree (not target/ancestor/descendant). */
 function hitTest(el, rect) {
     const top = hitTestOccluder(el, rect);
-    return top === null
+    return null === top
         ? { occluded: false, occludedBy: null }
         : { occluded: true, occludedBy: refs.refFor(top) };
 }
@@ -56,7 +70,7 @@ export function clickGeometry(el) {
     if (!isMeasurable(rect))
         return NO_GEOMETRY;
     let scrolledIntoView = false;
-    if (isOffViewport(el, rect) && typeof el.scrollIntoView === 'function') {
+    if (isOffViewport(el, rect) && 'function' === typeof el.scrollIntoView) {
         el.scrollIntoView({ block: 'center', inline: 'center' });
         scrolledIntoView = true;
         rect = el.getBoundingClientRect();
@@ -64,7 +78,7 @@ export function clickGeometry(el) {
     return { ...hitTest(el, rect), scrolledIntoView };
 }
 export function firePointer(el, type, relatedTarget = null) {
-    if (typeof PointerEvent === 'function') {
+    if ('function' === typeof PointerEvent) {
         el.dispatchEvent(new PointerEvent(type, { bubbles: true, cancelable: true, relatedTarget }));
     }
     else {
@@ -73,7 +87,7 @@ export function firePointer(el, type, relatedTarget = null) {
 }
 /** Enter/leave pointer events are non-bubbling per spec; keep them so to avoid double-firing. */
 export function firePointerNonBubbling(el, type, relatedTarget = null) {
-    if (typeof PointerEvent === 'function') {
+    if ('function' === typeof PointerEvent) {
         el.dispatchEvent(new PointerEvent(type, { bubbles: false, cancelable: true, relatedTarget }));
     }
     else {
@@ -87,9 +101,9 @@ function makeDataTransfer(data) {
     // data: { mime, value } or [{ mime, value }, …]
     const entries = Array.isArray(data) ? data : data !== undefined ? [data] : [];
     for (const entry of entries) {
-        if (typeof entry === 'object' && entry !== null) {
+        if ('object' === typeof entry && entry !== null) {
             const e = entry;
-            if (typeof e.mime === 'string' && typeof e.value === 'string')
+            if ('string' === typeof e.mime && 'string' === typeof e.value)
                 dt.setData(e.mime, e.value);
         }
     }
@@ -102,7 +116,7 @@ function makeDataTransfer(data) {
 export async function dragElement(source, target, data) {
     const dest = target ?? source;
     const fire = (el, type) => {
-        if (typeof PointerEvent === 'function' && type.startsWith('pointer')) {
+        if ('function' === typeof PointerEvent && type.startsWith('pointer')) {
             el.dispatchEvent(new PointerEvent(type, { bubbles: true, cancelable: true }));
         }
         else {
@@ -118,7 +132,7 @@ export async function dragElement(source, target, data) {
     fire(dest, 'pointerup');
     fire(dest, 'mouseup');
     let dropPrevented = false;
-    if (typeof DragEvent === 'function') {
+    if ('function' === typeof DragEvent) {
         const dataTransfer = makeDataTransfer(data);
         const init = { bubbles: true, cancelable: true };
         if (dataTransfer !== null)

package/dist/actions/actions.d.ts

@@ -21,6 +21,18 @@ interface ActionEffect {
     valueChanged: boolean;
     /** Mutation records counted by a short-lived MutationObserver (one microtask + rAF window). */
     domMutatedWithin: number;
+    /**
+     * Text the action put on the page, truncated. OMITTED when it added none.
+     *
+     * `domMutatedWithin` says the click did SOMETHING; it cannot say the app rejected you. A login
+     * that fails returns ok/settled/mutated and reads exactly like one that succeeded, so an agent
+     * moves on and asserts against a page it misread. The observer already receives these records
+     * and was keeping only `.length` — the message was being thrown away, not gathered.
+     *
+     * Deliberately NOT a verdict: this is what appeared, not what it means. Absence means no text
+     * was added, which is why a silent class toggle omits the key rather than reporting "".
+     */
+    appeared?: string;
     /**
      * Click-like only: the center hit-tested to a foreign element (an overlay is on top). Synthetic
      * dispatch STILL delivered the event to the target, but a real user could not click it — treat
@@ -31,6 +43,14 @@ interface ActionEffect {
     occludedBy: string | null;
     /** Click-like only: the target was off-viewport, so it was scrolled into view before dispatch. */
     scrolledIntoView: boolean;
+    /**
+     * How long the pointer was ACTUALLY held down, for a click with `args.holdMs`. Absent otherwise.
+     *
+     * Measured, not echoed. `holdMs: 1200` against a 1200ms animation is a race by construction, so a
+     * caller needs to tell "held 1200" from "held 1204" — and a backgrounded tab throttles timers, so
+     * the achieved hold can legitimately be much longer than the one requested.
+     */
+    heldMs?: number;
 }
 interface ActionResult {
     ok: true;
@@ -62,6 +82,19 @@ interface ActionResult {
     /** Best-effort caveat the agent should heed (e.g. synthetic hover may not fire enter/leave). */
     warning?: string;
 }
+/**
+ * Dispatch the action's events. Returns `defaultPrevented` of the primary cancelable event
+ * (false for actions whose primary event is non-cancelable or unobservable). Drag/hover-hold
+ * await internally; the probe wrapper builds the result once they resolve.
+ */
+/**
+ * The longest a single action may hold the pointer down, in milliseconds.
+ *
+ * An unbounded `holdMs` is a tool call that never returns, which is the failure the transport layer
+ * is shaped around. 30s is far above any real hold-to-confirm (the reported case was 1.2s) and far
+ * below a hang.
+ */
+export declare const MAX_HOLD_MS = 30000;
 /**
  * Execute a single action against a ref and probe for best-effort evidence of effect.
  * Always async: the MutationObserver read needs a microtask + rAF after dispatch.
@@ -81,7 +114,20 @@ interface SequenceStepResult {
     dispatched: boolean;
     settled: boolean;
     settleReason: SettleReason | null;
+    /**
+     * The SAME anchors a single act reports. Reporting only the testid meant a testid-less app
+     * compiled every sub-step to a volatile ref, so the saved flow carried the degraded sentinel and
+     * every replay drifted.
+     */
     testid?: string;
+    component?: string;
+    role?: string;
+    name?: string;
+    source?: {
+        file: string;
+        line: number;
+        column?: number;
+    };
     /** best-effort caveat for this step (e.g. synthetic hover may not fire enter/leave). */
     warning?: string;
 }

package/dist/actions/actions.js

@@ -1,19 +1,20 @@
 import { ActionType, ActionWarning, DANGEROUS_ACTION_CONFIRM_ARG, ElementState, isDangerousActionText, SettleReason, } from '@reticlehq/core';
-import { refs } from '../dom/refs.js';
+import { echoRef, refs } from '../dom/refs.js';
 import { assertEditable, assertNotRichText, setNativeValue } from './value-input.js';
 import { getAccessibleName, getRole, isVisible, getStates } from '../dom/a11y.js';
 import { elementHasHoverHandlers, identifyComponent } from '../registry/adapters.js';
 import { isForm, isHtmlElement, isInput, isSelect, isTextArea } from '../dom/realm.js';
 import { nativeSetTimeout, settle } from '../timers/native-timers.js';
+import { AppearedText } from './appeared-text.js';
 function asString(value, fallback = '') {
-    return typeof value === 'string' ? value : fallback;
+    return 'string' === typeof value ? value : fallback;
 }
 function requireElement(ref) {
     const el = refs.resolve(ref);
-    if (el === null)
-        throw new Error(`ref '${ref}' no longer resolves to an element`);
+    if (null === el)
+        throw new Error(`ref '${echoRef(ref)}' no longer resolves to an element`);
     if (!isHtmlElement(el))
-        throw new Error(`ref '${ref}' is not an HTMLElement`);
+        throw new Error(`ref '${echoRef(ref)}' is not an HTMLElement`);
     return el;
 }
 /**
@@ -39,12 +40,20 @@ function anchorOf(el) {
         out.component = component;
     if (info?.source !== undefined)
         out.source = info.source;
+    // Reported INDEPENDENTLY. They used to be all-or-nothing, so an element with a role and no
+    // accessible name — an icon button, a clickable div, a control labelled by an SVG — came back with
+    // no identity at all once identifyComponent (React-specific) also found nothing. Two features read
+    // this and both silently degrade without it: the flow recorder anchors a step by it, and coverage
+    // recognises a control it already drove across a re-render by it.
+    //
+    // A role alone is not a unique anchor, and the flow compiler still requires role AND name before it
+    // will anchor a step that way. But it is real information, and reporting it beats reporting nothing.
     const role = getRole(el);
     const name = getAccessibleName(el);
-    if (role.length > 0 && name.length > 0) {
+    if (role.length > 0)
         out.role = role;
+    if (name.length > 0)
         out.name = name;
-    }
     return out;
 }
 const result = (ref, action, effect, settled, settleReason, anchor, warning) => {
@@ -108,7 +117,7 @@ function assertActionAllowed(el, action, args) {
         action === ActionType.DBLCLICK ||
         action === ActionType.DRAG ||
         action === ActionType.SUBMIT ||
-        (action === ActionType.PRESS && asString(args['key'], 'Enter') === 'Enter');
+        (action === ActionType.PRESS && 'Enter' === asString(args['key'], 'Enter'));
     const dragTarget = action === ActionType.DRAG ? refs.resolve(asString(args['toRef'])) : null;
     const context = isHtmlElement(dragTarget)
         ? `${dangerousActionContext(el)} ${dangerousActionContext(dragTarget)}`
@@ -135,7 +144,7 @@ function valueOf(el) {
 /** Ref of the currently-focused element, treating body/null as "no focus". */
 function activeRef(el) {
     const active = el.ownerDocument.activeElement;
-    if (active === null || active === el.ownerDocument.body)
+    if (null === active || active === el.ownerDocument.body)
         return null;
     return refs.refFor(active);
 }
@@ -144,12 +153,38 @@ function activeRef(el) {
  * (false for actions whose primary event is non-cancelable or unobservable). Drag/hover-hold
  * await internally; the probe wrapper builds the result once they resolve.
  */
+/**
+ * The longest a single action may hold the pointer down, in milliseconds.
+ *
+ * An unbounded `holdMs` is a tool call that never returns, which is the failure the transport layer
+ * is shaped around. 30s is far above any real hold-to-confirm (the reported case was 1.2s) and far
+ * below a hang.
+ */
+export const MAX_HOLD_MS = 30_000;
+/** A hold the caller asked for, bounded and sanitised. Non-numbers and negatives mean "no hold". */
+function clampHold(raw) {
+    if ('number' !== typeof raw || !Number.isFinite(raw) || raw <= 0)
+        return 0;
+    return Math.min(raw, MAX_HOLD_MS);
+}
+/**
+ * Click is the only action that can hold the pointer down, so it is the only one that reports a
+ * duration. Everything else routes through the switch below unchanged and holds for zero.
+ */
 async function dispatchFor(el, action, args) {
+    if (ActionType.CLICK === action) {
+        // Full pointer/mouse sequence (not a bare click) so pointer- and focus-gated handlers fire the
+        // way they do for a real user.
+        //
+        // `args.holdMs` keeps the pointer down in between, which is the only way to drive a
+        // hold-to-confirm control. Capped: an unbounded hold is a tool call that never returns.
+        const hold = clampHold(args['holdMs']);
+        return await fireClickSequence(el, 0 === hold ? undefined : { ms: hold, sleep, now: () => Date.now() });
+    }
+    return { prevented: await dispatchOther(el, action, args), heldMs: 0 };
+}
+async function dispatchOther(el, action, args) {
     switch (action) {
-        case ActionType.CLICK:
-            // Full pointer/mouse sequence (not a bare click) so pointer- and focus-gated handlers fire
-            // the way they do for a real user. Returns the click event's defaultPrevented.
-            return fireClickSequence(el);
         case ActionType.DBLCLICK:
             return !el.dispatchEvent(new MouseEvent('dblclick', { bubbles: true, cancelable: true }));
         case ActionType.HOVER: {
@@ -164,8 +199,9 @@ async function dispatchFor(el, action, args) {
             el.dispatchEvent(new MouseEvent('mouseenter', { relatedTarget: from }));
             firePointer(el, 'pointermove', from);
             const moved = el.dispatchEvent(new MouseEvent('mousemove', { bubbles: true, cancelable: true }));
-            // hover-dwell: keep "hovering" for holdMs so timer-gated reveals can mount.
-            const holdMs = typeof args['holdMs'] === 'number' ? args['holdMs'] : 0;
+            // hover-dwell: keep "hovering" for holdMs so timer-gated reveals can mount. Same cap as
+            // click — this arg was previously unbounded here, which is the same never-returns hazard.
+            const holdMs = clampHold(args['holdMs']);
             if (holdMs > 0)
                 await sleep(holdMs);
             return !moved;
@@ -174,13 +210,31 @@ async function dispatchFor(el, action, args) {
             el.focus();
             el.dispatchEvent(new FocusEvent('focusin', { bubbles: true }));
             return false; // FocusEvents are not cancelable.
-        case ActionType.BLUR:
-            // Fire a bubbling focusout so React 19's delegated root listener runs onBlur
-            // (commit-on-blur). el.blur alone only works if the element was truly focused.
+        case ActionType.BLUR: {
+            // React 19 listens for `focusout` at the ROOT, so a commit-on-blur handler needs a BUBBLING
+            // event to reach it — and `el.blur()` is a no-op on an element that was never focused, which
+            // is why the synthetic pair exists at all.
+            //
+            // But on a FOCUSED element `el.blur()` already dispatches `blur` and a bubbling `focusout`
+            // natively. Dispatching them again meant React ran `onBlur` TWICE, and Reticle reported the
+            // resulting double write as a `duplicate-request` contradiction — a defect we invented and
+            // handed to a human as real. Reported from the field on React 19 + Vite with a single
+            // `onBlur={() => mutate(...)}`, one render site and no StrictMode.
+            //
+            // So synthesize ONLY when nothing native will fire. Read before the call, because `blur()` is
+            // what changes it — and read off the element's own ROOT: `document.activeElement` reports the
+            // shadow HOST for an element inside a shadow root, so an element that genuinely was focused
+            // would read as unfocused and take the double-dispatch path this exists to prevent. Both
+            // Document and ShadowRoot expose `activeElement`, so one expression covers both.
+            const root = el.getRootNode();
+            const wasFocused = root.activeElement === el;
             el.blur();
-            el.dispatchEvent(new FocusEvent('blur'));
-            el.dispatchEvent(new FocusEvent('focusout', { bubbles: true }));
+            if (!wasFocused) {
+                el.dispatchEvent(new FocusEvent('blur'));
+                el.dispatchEvent(new FocusEvent('focusout', { bubbles: true }));
+            }
             return false;
+        }
         case ActionType.FILL:
             if (isInput(el) || isTextArea(el)) {
                 // A MISSING value is a malformed call, not a request to empty the field. `asString` defaults
@@ -224,13 +278,27 @@ async function dispatchFor(el, action, args) {
             if (isSelect(el)) {
                 // A MISSING value assigned '' to the <select>. No option carries that, so the browser sets
                 // selectedIndex to -1 — deselecting everything — from a call that was simply malformed.
-                // (Selecting a value that no option carries is a different case and is deliberately NOT
-                // refused: `actions.effect.test.ts` pins it as a detectable no-op, where the reported
-                // valueChanged delta is what tells the agent the option never took.)
                 if (typeof args['value'] !== 'string') {
                     throw new Error("select requires a string `value` — pass it nested, as args: { value: '…' }.");
                 }
-                el.value = args['value'];
+                const wanted = args['value'];
+                const options = Array.from(el.options);
+                // REFUSE an option that does not exist, before touching the element.
+                //
+                // This used to assign anyway and report the resulting `valueChanged` delta as proof the
+                // option never took. That only works if nobody is listening. An unmatched value drives
+                // selectedIndex to -1, so `el.value` becomes '' — and we then dispatched `change`. Reported
+                // from a real session: the app read that empty value in its change handler and persisted it,
+                // corrupting a stored language setting. The "detectable no-op" both mutated the app into a
+                // state no user could reach AND did it through the app's own handler.
+                //
+                // Same rule as the readonly/disabled refusal: if a real user could not do it, forcing it is
+                // not a test, it is damage.
+                if (!options.some((option) => option.value === wanted)) {
+                    const available = options.map((option) => `${option.value} (${option.label})`).join(', ');
+                    throw new Error(`no <option> with value '${echoRef(wanted)}' — available: ${0 === options.length ? '(none)' : available}`);
+                }
+                el.value = wanted;
                 el.dispatchEvent(new Event('change', { bubbles: true }));
                 return false; // change is not cancelable.
             }
@@ -245,7 +313,7 @@ async function dispatchFor(el, action, args) {
             throw new Error(`cannot (un)check a <${el.tagName.toLowerCase()}>`);
         case ActionType.SUBMIT: {
             const form = isForm(el) ? el : el.closest('form');
-            if (form === null)
+            if (null === form)
                 throw new Error('no form to submit');
             form.requestSubmit();
             return false; // requestSubmit returns void; the internal submit event is unobservable.
@@ -301,8 +369,10 @@ export async function executeAction(ref, action, args = {}) {
     // mutation observer (scroll/hit-test never mutate the DOM, but keep the probe window clean).
     const geometry = CLICK_LIKE.has(action) ? clickGeometry(el) : NO_GEOMETRY;
     let mutated = 0;
+    const said = new AppearedText();
     const obs = new MutationObserver((records) => {
         mutated += records.length;
+        said.collect(records);
     });
     obs.observe(el.ownerDocument.documentElement, {
         subtree: true,
@@ -311,10 +381,14 @@ export async function executeAction(ref, action, args = {}) {
         characterData: true,
     });
     let defaultPrevented = false;
+    /** How long the pointer was actually held down. Zero for every action that cannot hold. */
+    let heldMs = 0;
     let settled = false;
     let settleReason = null;
     try {
-        defaultPrevented = await dispatchFor(el, action, args);
+        const outcome = await dispatchFor(el, action, args);
+        defaultPrevented = outcome.prevented;
+        heldMs = outcome.heldMs;
     }
     finally {
         // bounded settle — microtask + one BOUNDED frame so React's commit (and the resulting DOM
@@ -337,9 +411,15 @@ export async function executeAction(ref, action, args = {}) {
         focusMoved: prevFocus !== nextFocus ? `${prevFocus ?? 'null'}->${nextFocus ?? 'null'}` : null,
         valueChanged: isFillLike(action) ? valueBefore !== valueAfter : false,
         domMutatedWithin: mutated,
+        // Omitted rather than "" when nothing was said — an empty string reads as "it said nothing
+        // meaningful", where absence says "it added no text at all". Those are different findings.
+        ...said.effect(valueAfter),
         occluded: geometry.occluded,
         occludedBy: geometry.occludedBy,
         scrolledIntoView: geometry.scrolledIntoView,
+        // Omitted when there was no hold: an absent key says "this action does not hold", where a 0
+        // would read as "it held for no time", which is a different and misleading claim.
+        ...(heldMs > 0 ? { heldMs } : {}),
     };
     // Honesty caveats: a visually-occluded click is reported even though synthetic dispatch landed;
     // else synthetic hover may not fire framework enter/leave handlers (no native hit-test).
@@ -377,6 +457,14 @@ export async function executeSequence(steps) {
         };
         if (res.testid !== undefined)
             stepBase.testid = res.testid;
+        if (res.component !== undefined)
+            stepBase.component = res.component;
+        if (res.role !== undefined)
+            stepBase.role = res.role;
+        if (res.name !== undefined)
+            stepBase.name = res.name;
+        if (res.source !== undefined)
+            stepBase.source = res.source;
         if (res.warning !== undefined)
             stepBase.warning = res.warning;
         stepResults.push(stepBase);

package/dist/actions/appeared-text.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Gathers the text an action put on the page, from mutation records the observer already receives.
+ *
+ * `domMutatedWithin` counts records and throws their content away, so a failed login reports
+ * `ok / settled / mutated` and reads exactly like a successful one. The message the app rendered
+ * was passing through this callback the whole time.
+ *
+ * Deliberately reports what appeared, never what it means: no error/success classification, no
+ * guessing which fragment matters. Truncated, because a route change can add a whole page.
+ */
+export declare class AppearedText {
+    #private;
+    collect(records: readonly MutationRecord[]): void;
+    /**
+     * `{ appeared }` when the APP added text, `{}` otherwise — an absent key means it added none.
+     *
+     * `wrote` is the value the action itself just set, and is excluded: a textarea carries its value
+     * in a child text node, so a controlled one re-rendering after the write mutates characterData
+     * with the caller's own string. Handing that back is noise wearing the name of evidence, and
+     * `valueChanged` already reports that the write landed. Exact-match only, so an app that quotes
+     * your input inside a sentence of its own ("No results for zzz") is still reported — that is
+     * the app talking.
+     */
+    effect(wrote?: string): {
+        appeared?: string;
+    };
+}

package/dist/actions/appeared-text.js

@@ -0,0 +1,92 @@
+import { isIgnored } from '../dom/dom-ignore.js';
+/** Cap on the reported text. Enough for an error message, far short of a re-rendered page. */
+const APPEARED_MAX = 200;
+/** Separator between distinct fragments that appeared in the same window. */
+const JOIN = ' | ';
+const TEXT_NODE = 3;
+/** Any letter, in any script — Latin, Cyrillic, CJK, Arabic. */
+const HAS_LETTER = /\p{L}/u;
+/**
+ * A fragment with no letters at all is not the app saying something.
+ *
+ * The Hostile fixture mutates a counter every 16ms, and clicking a button on that page reported
+ * `appeared: "409"` — the ticker, not the action's effect. A count-up animation is exactly what
+ * emits a bare number into the settle window, and a bare number carries no message a reader can
+ * act on. Deliberately conservative: it drops only fragments with NO letters, so "status 500",
+ * "3 items deleted" and "Could not save" all survive. An app whose only feedback is a naked
+ * numeral loses it here — the snapshot still shows it, and that is the cheaper mistake.
+ */
+function saysSomething(text) {
+    return HAS_LETTER.test(text);
+}
+/**
+ * Gathers the text an action put on the page, from mutation records the observer already receives.
+ *
+ * `domMutatedWithin` counts records and throws their content away, so a failed login reports
+ * `ok / settled / mutated` and reads exactly like a successful one. The message the app rendered
+ * was passing through this callback the whole time.
+ *
+ * Deliberately reports what appeared, never what it means: no error/success classification, no
+ * guessing which fragment matters. Truncated, because a route change can add a whole page.
+ */
+export class AppearedText {
+    #seen = new Set();
+    #length = 0;
+    collect(records) {
+        for (const record of records) {
+            if (this.#full())
+                return;
+            if ('characterData' === record.type) {
+                // The NEW value; oldValue is not requested, so this is what the reader now sees.
+                this.#add(record.target.textContent, record.target.parentElement);
+                continue;
+            }
+            for (const node of record.addedNodes) {
+                if (this.#full())
+                    return;
+                const owner = TEXT_NODE === node.nodeType ? node.parentElement : elementOf(node);
+                this.#add(node.textContent, owner);
+            }
+        }
+    }
+    /**
+     * `{ appeared }` when the APP added text, `{}` otherwise — an absent key means it added none.
+     *
+     * `wrote` is the value the action itself just set, and is excluded: a textarea carries its value
+     * in a child text node, so a controlled one re-rendering after the write mutates characterData
+     * with the caller's own string. Handing that back is noise wearing the name of evidence, and
+     * `valueChanged` already reports that the write landed. Exact-match only, so an app that quotes
+     * your input inside a sentence of its own ("No results for zzz") is still reported — that is
+     * the app talking.
+     */
+    effect(wrote) {
+        const said = [...this.#seen].filter((text) => text !== wrote);
+        if (0 === said.length)
+            return {};
+        const joined = said.join(JOIN);
+        return {
+            appeared: joined.length > APPEARED_MAX ? `${joined.slice(0, APPEARED_MAX)}…` : joined,
+        };
+    }
+    #full() {
+        return this.#length > APPEARED_MAX;
+    }
+    #add(raw, owner) {
+        // Reticle's own overlay mutates constantly (the "live" panel); reporting it as the app's
+        // response would be worse than reporting nothing.
+        if (null !== owner && isIgnored(owner))
+            return;
+        const text = (raw ?? '').replace(/\s+/g, ' ').trim();
+        if (0 === text.length)
+            return;
+        if (!saysSomething(text))
+            return;
+        if (this.#seen.has(text))
+            return;
+        this.#seen.add(text);
+        this.#length += text.length + JOIN.length;
+    }
+}
+function elementOf(node) {
+    return node instanceof Element ? node : node.parentElement;
+}

package/dist/actions/scroll.js

@@ -6,7 +6,7 @@ function nearestScrollable(el) {
     let cur = el;
     while (cur !== null && cur !== document.body) {
         const oy = getComputedStyle(cur).overflowY;
-        if ((oy === 'auto' || oy === 'scroll') && cur.scrollHeight > cur.clientHeight)
+        if (('auto' === oy || 'scroll' === oy) && cur.scrollHeight > cur.clientHeight)
             return cur;
         cur = cur.parentElement;
     }