@reticlehq/browser 3.6.0 → 3.8.0

package/dist/actions/action-report.d.ts

@@ -0,0 +1,64 @@
+import { type SettleReason } from '@reticlehq/core';
+export interface ActionEffect {
+    dispatched: true;
+    targetMatched: boolean;
+    visible: boolean;
+    enabled: boolean;
+    defaultPrevented: boolean;
+    focusMoved: string | null;
+    valueChanged: boolean;
+    autofillSafe?: true;
+    domMutatedWithin: number;
+    appeared?: string;
+    occluded: boolean;
+    occludedBy: string | null;
+    scrolledIntoView: boolean;
+    occluderName?: string;
+    noSize?: true;
+    offViewport?: true;
+    heldMs?: number;
+    alreadyAtValue?: true;
+    canvases?: number;
+}
+export declare function visibleCanvases(doc: Document): number;
+export interface ActionResult {
+    ok: true;
+    ref: string;
+    action: string;
+    dispatched: boolean;
+    settled: boolean;
+    settleReason: SettleReason | null;
+    effect: ActionEffect;
+    testid?: string;
+    testidOf?: number;
+    component?: string;
+    role?: string;
+    name?: string;
+    nth?: number;
+    of?: number;
+    source?: {
+        file: string;
+        line: number;
+        column?: number;
+    };
+    secret?: true;
+    warning?: string;
+    reticleUi?: true;
+}
+export interface CapturedAnchor {
+    testid?: string;
+    testidOf?: number;
+    component?: string;
+    source?: {
+        file: string;
+        line: number;
+        column?: number;
+    };
+    role?: string;
+    name?: string;
+    nth?: number;
+    of?: number;
+    secret?: true;
+}
+export declare function anchorOf(el: Element): CapturedAnchor;
+export declare const result: (ref: string, action: string, effect: ActionEffect, settled: boolean, settleReason: SettleReason | null, anchor: CapturedAnchor, warning?: string) => ActionResult;

package/dist/actions/action-report.js

@@ -0,0 +1,87 @@
+import { readTestId } from '../dom/addressing/testid-attr.js';
+import { QueryBy } from '@reticlehq/core';
+import { elementsMatching } from '../dom/query.js';
+import { getAccessibleName, getRole, isSensitiveField } from '../dom/a11y.js';
+import { identifyComponent } from '../registry/stores/adapters.js';
+import { isReticleUi } from '../dom/dom-ignore.js';
+const CANVAS_SELECTOR = 'canvas';
+export function visibleCanvases(doc) {
+    const width = doc.defaultView?.innerWidth ?? 0;
+    const height = doc.defaultView?.innerHeight ?? 0;
+    let count = 0;
+    for (const canvas of doc.querySelectorAll(CANVAS_SELECTOR)) {
+        if (isReticleUi(canvas))
+            continue;
+        const box = canvas.getBoundingClientRect();
+        const sized = box.width > 0 && box.height > 0;
+        const onScreen = box.bottom > 0 && box.right > 0 && box.top < height && box.left < width;
+        if (sized && onScreen)
+            count += 1;
+    }
+    return count;
+}
+export function anchorOf(el) {
+    const testid = readTestId(el) ?? undefined;
+    const info = identifyComponent(el);
+    const out = {};
+    if (testid !== undefined) {
+        out.testid = testid;
+        const shared = elementsMatching({ by: QueryBy.TESTID, value: testid }).length;
+        if (1 < shared)
+            out.testidOf = shared;
+    }
+    const component = info?.componentStack[0];
+    if (component !== undefined)
+        out.component = component;
+    if (info?.source !== undefined)
+        out.source = info.source;
+    const role = getRole(el);
+    const name = getAccessibleName(el);
+    if (role.length > 0)
+        out.role = role;
+    if (name.length > 0)
+        out.name = name;
+    if (isSensitiveField(el))
+        out.secret = true;
+    if (role.length > 0 && name.length > 0) {
+        const same = elementsMatching({ by: QueryBy.ROLE, value: role, name });
+        const at = same.indexOf(el);
+        if (1 < same.length && 0 <= at) {
+            out.nth = at;
+            out.of = same.length;
+        }
+    }
+    return out;
+}
+export const result = (ref, action, effect, settled, settleReason, anchor, warning) => {
+    const base = {
+        ok: true,
+        ref,
+        action,
+        dispatched: true,
+        settled,
+        settleReason,
+        effect,
+    };
+    if (anchor.testid !== undefined)
+        base.testid = anchor.testid;
+    if (anchor.testidOf !== undefined)
+        base.testidOf = anchor.testidOf;
+    if (anchor.component !== undefined)
+        base.component = anchor.component;
+    if (anchor.source !== undefined)
+        base.source = anchor.source;
+    if (anchor.role !== undefined)
+        base.role = anchor.role;
+    if (anchor.name !== undefined)
+        base.name = anchor.name;
+    if (anchor.nth !== undefined)
+        base.nth = anchor.nth;
+    if (anchor.of !== undefined)
+        base.of = anchor.of;
+    if (anchor.secret !== undefined)
+        base.secret = anchor.secret;
+    if (warning !== undefined)
+        base.warning = warning;
+    return base;
+};

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

@@ -3,6 +3,9 @@ interface ClickGeometry {
     occluded: boolean;
     occludedBy: string | null;
     scrolledIntoView: boolean;
+    occluderName?: string;
+    noSize?: true;
+    offViewport?: true;
 }
 export declare const NO_GEOMETRY: ClickGeometry;
 export declare function mouseEventFor(el: Element, type: string, init?: MouseEventInit): MouseEvent;
@@ -14,6 +17,7 @@ export declare function fireClickSequence(el: ActionTarget, hold?: {
     prevented: boolean;
     heldMs: number;
 }>;
+export declare function isOffViewport(el: Element, rect: DOMRect): boolean;
 export declare function clickGeometry(el: ActionTarget): ClickGeometry;
 export declare function firePointer(el: Element, type: string, relatedTarget?: EventTarget | null): void;
 export declare function firePointerNonBubbling(el: Element, type: string, relatedTarget?: EventTarget | null): void;
@@ -26,4 +30,5 @@ export declare function fireTapSequence(el: ActionTarget, hold: {
     prevented: boolean;
     heldMs: number;
 }>;
+export declare function assertNotLeaving(el: Element): void;
 export {};

package/dist/actions/actions-dom.js

@@ -1,4 +1,6 @@
 import { refs } from '../dom/addressing/refs.js';
+import { readTestId } from '../dom/addressing/testid-attr.js';
+import { getAccessibleName, getRole } from '../dom/a11y.js';
 import { hitTestOccluder } from '../dom/occlusion.js';
 import { nativeFrame } from '../timers/native/native-timers.js';
 import { asSyntheticInput } from './synthetic/synthetic-input.js';
@@ -58,7 +60,7 @@ export async function fireClickSequence(el, hold, detail) {
 function isMeasurable(rect) {
     return rect.width > 0 || rect.height > 0;
 }
-function isOffViewport(el, rect) {
+export function isOffViewport(el, rect) {
     const win = el.ownerDocument.defaultView;
     if (null === win)
         return false;
@@ -70,21 +72,35 @@ function hitTest(el, rect) {
     const top = hitTestOccluder(el, rect);
     return null === top
         ? { occluded: false, occludedBy: null }
-        : { occluded: true, occludedBy: refs.refFor(top) };
+        : { occluded: true, occludedBy: refs.refFor(top), occluderName: nameOf(top) };
+}
+function nameOf(el) {
+    const testid = readTestId(el);
+    if (testid !== null && testid.length > 0)
+        return `[data-testid="${testid}"]`;
+    const name = getAccessibleName(el).trim();
+    return name.length > 0 ? `${getRole(el)} "${name.slice(0, 40)}"` : el.tagName.toLowerCase();
+}
+function hasNoSize(el) {
+    if (typeof el.getClientRects !== 'function')
+        return false;
+    const rects = Array.from(el.getClientRects());
+    return rects.length > 0 && rects.every((r) => 0 === r.width || 0 === r.height);
 }
 export function clickGeometry(el) {
     if (typeof el.getBoundingClientRect !== 'function')
         return NO_GEOMETRY;
     let rect = el.getBoundingClientRect();
     if (!isMeasurable(rect))
-        return NO_GEOMETRY;
+        return hasNoSize(el) ? { ...NO_GEOMETRY, noSize: true } : NO_GEOMETRY;
     let scrolledIntoView = false;
     if (isOffViewport(el, rect) && 'function' === typeof el.scrollIntoView) {
         el.scrollIntoView({ block: 'center', inline: 'center' });
         scrolledIntoView = true;
         rect = el.getBoundingClientRect();
     }
-    return { ...hitTest(el, rect), scrolledIntoView };
+    const stillOff = scrolledIntoView && isOffViewport(el, rect);
+    return { ...hitTest(el, rect), scrolledIntoView, ...(stillOff ? { offViewport: true } : {}) };
 }
 export function firePointer(el, type, relatedTarget = null) {
     asSyntheticInput(() => el.dispatchEvent(pointerEventFor(el, type, { bubbles: true, cancelable: true, relatedTarget })));
@@ -231,3 +247,15 @@ function makeTouchEvent(type, touches) {
     }
     return new Event(type, { bubbles: true, cancelable: true });
 }
+const POPUP_ROLES = new Set(['menu', 'menubar', 'listbox', 'dialog', 'alertdialog', 'tooltip']);
+const CLOSED_STATE = 'closed';
+export function assertNotLeaving(el) {
+    for (let up = el.parentElement; up !== null; up = up.parentElement) {
+        if (CLOSED_STATE !== up.getAttribute('data-state'))
+            continue;
+        if (!POPUP_ROLES.has(up.getAttribute('role') ?? ''))
+            continue;
+        throw new Error(`'${up.getAttribute('role') ?? 'popup'}' holding this element is closing (data-state="closed"), ` +
+            'so a person could not click it: look again once it has gone and act on what is open');
+    }
+}

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

@@ -8,6 +8,7 @@ export interface ModifierFlags {
 }
 export declare function pressModifiers(args: Record<string, unknown>): ModifierFlags;
 export declare function pressCode(args: Record<string, unknown>, key: string): string;
+export declare function dispatchKeypress(el: ActionTarget, key: string, code: string, mods: ModifierFlags, repeat?: boolean): void;
 export declare function focusedOrDocument(): HTMLElement;
 export declare function isReflessDocumentPress(ref: string, action: string, args: Record<string, unknown>): boolean;
 export declare function pressKeys(args: Record<string, unknown>): string[];

package/dist/actions/actions-press.js

@@ -57,6 +57,26 @@ export function pressCode(args, key) {
     }
     return /^[A-Z][A-Za-z0-9]*$/.test(key) && KNOWN_NAMED_KEYS.has(key) ? key : '';
 }
+export function dispatchKeypress(el, key, code, mods, repeat = false) {
+    if (ENTER_KEY !== key && 1 !== key.length)
+        return;
+    const event = new KeyboardEvent('keypress', {
+        key,
+        code,
+        bubbles: true,
+        cancelable: true,
+        repeat,
+        ...mods,
+    });
+    const legacy = ENTER_KEY === key ? ENTER_CHAR_CODE : key.charCodeAt(0);
+    for (const field of LEGACY_KEY_CODE_FIELDS) {
+        Object.defineProperty(event, field, { value: legacy });
+    }
+    asSyntheticInput(() => el.dispatchEvent(event));
+}
+const ENTER_KEY = 'Enter';
+const ENTER_CHAR_CODE = 13;
+const LEGACY_KEY_CODE_FIELDS = ['keyCode', 'charCode', 'which'];
 const KNOWN_NAMED_KEYS = new Set([
     'Enter',
     'Escape',
@@ -139,7 +159,7 @@ export async function holdKey(el, key, code, mods, ms) {
     if (ms > KEY_REPEAT_DELAY_MS)
         await sleep(KEY_REPEAT_DELAY_MS);
     while (Date.now() - started < ms) {
-        asSyntheticInput(() => el.dispatchEvent(keyboardEvent('keydown', {
+        const down = asSyntheticInput(() => el.dispatchEvent(keyboardEvent('keydown', {
             key,
             code,
             bubbles: true,
@@ -147,6 +167,8 @@ export async function holdKey(el, key, code, mods, ms) {
             repeat: true,
             ...mods,
         })));
+        if (down)
+            dispatchKeypress(el, key, code, mods, true);
         await sleep(Math.min(KEY_REPEAT_MS, Math.max(0, ms - (Date.now() - started))));
     }
 }
@@ -179,6 +201,8 @@ export async function pressCombo(el, keys, mods, holdMs) {
         const ok = dispatch('keydown', key);
         if (!ok)
             prevented = true;
+        if (ok)
+            dispatchKeypress(el, key, pressCode({}, key), held);
         closeModalOnEscape(el, key, ok);
     }
     if (holdMs > 0)

package/dist/actions/actions.d.ts

@@ -1,41 +1,5 @@
 import { SettleReason } from '@reticlehq/core';
-interface ActionEffect {
-    dispatched: true;
-    targetMatched: boolean;
-    visible: boolean;
-    enabled: boolean;
-    defaultPrevented: boolean;
-    focusMoved: string | null;
-    valueChanged: boolean;
-    domMutatedWithin: number;
-    appeared?: string;
-    occluded: boolean;
-    occludedBy: string | null;
-    scrolledIntoView: boolean;
-    heldMs?: number;
-    alreadyAtValue?: true;
-}
-interface ActionResult {
-    ok: true;
-    ref: string;
-    action: string;
-    dispatched: boolean;
-    settled: boolean;
-    settleReason: SettleReason | null;
-    effect: ActionEffect;
-    testid?: string;
-    component?: string;
-    role?: string;
-    name?: string;
-    nth?: number;
-    of?: number;
-    source?: {
-        file: string;
-        line: number;
-        column?: number;
-    };
-    warning?: string;
-}
+import { type ActionEffect, type ActionResult } from './action-report.js';
 export declare const ZOOM_NEEDS_REAL_BROWSER_MSG: string;
 export declare function executeAction(ref: string, action: string, args?: Record<string, unknown>): Promise<ActionResult>;
 export interface ActionStep {
@@ -58,6 +22,7 @@ interface SequenceStepResult {
         line: number;
         column?: number;
     };
+    secret?: true;
     warning?: string;
 }
 export declare function executeSequence(steps: ActionStep[]): Promise<{

package/dist/actions/actions.js

@@ -1,17 +1,19 @@
-import { readTestId } from '../dom/addressing/testid-attr.js';
-import { ActionType, ActionWarning, clampHoldMs, DANGEROUS_ACTION_CONFIRM_ARG, ElementState, NATIVE_INPUT_ARG, QueryBy, SettleReason, } from '@reticlehq/core';
-import { elementsMatching } from '../dom/query.js';
+import { ActionType, ActionWarning, clampHoldMs, DANGEROUS_ACTION_CONFIRM_ARG, ElementState, NATIVE_INPUT_ARG, SettleReason, } from '@reticlehq/core';
+import { isHiddenNativeOption } from '../dom/query.js';
+import { isReticleUi } from '../dom/dom-ignore.js';
 import { asSyntheticInput } from './synthetic/synthetic-input.js';
 import { echoRef, refs } from '../dom/addressing/refs.js';
-import { dangerousActionContext, requiresDangerousConfirmation, submitControlFor, } from './danger-context.js';
-import { assertEditable, assertNotRichText, setNativeValue } from './value-input.js';
-import { getAccessibleName, getRole, isVisible, getStates } from '../dom/a11y.js';
-import { elementHasHoverHandlers, identifyComponent } from '../registry/stores/adapters.js';
+import { requiresDangerousConfirmation, assertOutwardAllowed, assertPaymentEntryAllowed, submitControlFor, } from './danger-context.js';
+import { assertEditable, assertNotRichText, isAutofillSafeTarget, setNativeValue, } from './value-input.js';
+import { isVisible, getStates } from '../dom/a11y.js';
+import { elementHasHoverHandlers } from '../registry/stores/adapters.js';
 import { isActionTarget, isForm, isInput, isSelect, isTextArea, } from '../dom/realm.js';
-import { nativeSetTimeout, settle } from '../timers/native/native-timers.js';
+import { asSettleBudget, nativeSetTimeout, settle } from '../timers/native/native-timers.js';
+import { publishSettledField, watchActedField } from '../observers/field.js';
 import { AppearedText } from './appeared-text.js';
 import { alreadyAtCheckedState, assertAriaToggleLanded, isAriaToggle } from './check-state.js';
-import { focusedOrDocument, isReflessDocumentPress, pressCode, pressKey, pressModifiers, pressKeys, holdKey, pressCombo, closeModalOnEscape, keyboardEvent, } from './actions-press.js';
+import { focusedOrDocument, isReflessDocumentPress, pressCode, pressKey, pressModifiers, pressKeys, holdKey, pressCombo, dispatchKeypress, closeModalOnEscape, keyboardEvent, } from './actions-press.js';
+import { anchorOf, result, visibleCanvases, } from './action-report.js';
 function asString(value, fallback = '') {
     return 'string' === typeof value ? value : fallback;
 }
@@ -23,61 +25,6 @@ function requireElement(ref) {
         throw new Error(`ref '${echoRef(ref)}' is not an HTML or SVG element`);
     return el;
 }
-function anchorOf(el) {
-    const testid = readTestId(el) ?? undefined;
-    const info = identifyComponent(el);
-    const out = {};
-    if (testid !== undefined)
-        out.testid = testid;
-    const component = info?.componentStack[0];
-    if (component !== undefined)
-        out.component = component;
-    if (info?.source !== undefined)
-        out.source = info.source;
-    const role = getRole(el);
-    const name = getAccessibleName(el);
-    if (role.length > 0)
-        out.role = role;
-    if (name.length > 0)
-        out.name = name;
-    if (role.length > 0 && name.length > 0) {
-        const same = elementsMatching({ by: QueryBy.ROLE, value: role, name });
-        const at = same.indexOf(el);
-        if (1 < same.length && 0 <= at) {
-            out.nth = at;
-            out.of = same.length;
-        }
-    }
-    return out;
-}
-const result = (ref, action, effect, settled, settleReason, anchor, warning) => {
-    const base = {
-        ok: true,
-        ref,
-        action,
-        dispatched: true,
-        settled,
-        settleReason,
-        effect,
-    };
-    if (anchor.testid !== undefined)
-        base.testid = anchor.testid;
-    if (anchor.component !== undefined)
-        base.component = anchor.component;
-    if (anchor.source !== undefined)
-        base.source = anchor.source;
-    if (anchor.role !== undefined)
-        base.role = anchor.role;
-    if (anchor.name !== undefined)
-        base.name = anchor.name;
-    if (anchor.nth !== undefined)
-        base.nth = anchor.nth;
-    if (anchor.of !== undefined)
-        base.of = anchor.of;
-    if (warning !== undefined)
-        base.warning = warning;
-    return base;
-};
 const FILL_LIKE = new Set([
     ActionType.FILL,
     ActionType.TYPE,
@@ -123,19 +70,31 @@ function assertActionAllowed(el, action, args) {
         (action === ActionType.PRESS && 'Enter' === pressKey(args));
     const dragTarget = action === ActionType.DRAG ? refs.resolve(dragTargetRef(args)) : null;
     const submitter = action === ActionType.PRESS && 'Enter' === pressKey(args) ? submitControlFor(el) : null;
-    const sourceDangerous = requiresDangerousConfirmation(dangerousActionContext(el), getRole(el)) ||
-        (submitter !== null &&
-            requiresDangerousConfirmation(dangerousActionContext(submitter), getRole(submitter)));
-    const targetDangerous = isActionTarget(dragTarget) &&
-        requiresDangerousConfirmation(dangerousActionContext(dragTarget), getRole(dragTarget));
+    if (canTrigger)
+        assertOutwardAllowed([el, submitter, isActionTarget(dragTarget) ? dragTarget : null]);
+    if (action === ActionType.FILL || action === ActionType.TYPE)
+        assertPaymentEntryAllowed(el);
+    const sourceDangerous = requiresDangerousConfirmation(el) ||
+        (submitter !== null && requiresDangerousConfirmation(submitter));
+    const targetDangerous = isActionTarget(dragTarget) && requiresDangerousConfirmation(dragTarget);
     if (canTrigger &&
         (sourceDangerous || targetDangerous) &&
         args[DANGEROUS_ACTION_CONFIRM_ARG] !== true) {
         throw new Error(`potentially destructive action blocked; retry with args.${DANGEROUS_ACTION_CONFIRM_ARG}=true`);
     }
+    if (CLICK_LIKE.has(action) && el instanceof HTMLElement && isHiddenNativeOption(el)) {
+        throw new Error('cannot click a native <option> inside a visually-hidden <select> — open the dropdown and target the visible option');
+    }
 }
-import { NO_GEOMETRY, fireClickSequence, fireTapSequence, clickGeometry, firePointer, firePointerNonBubbling, dragElement, mouseEventFor, } from './actions-dom.js';
+function optionValueFor(options, named) {
+    if (options.some((option) => option.value === named))
+        return named;
+    const byLabel = options.filter((option) => option.label.trim() === named.trim());
+    return 1 === byLabel.length ? (byLabel[0]?.value ?? named) : named;
+}
+import { NO_GEOMETRY, fireClickSequence, fireTapSequence, clickGeometry, firePointer, firePointerNonBubbling, dragElement, mouseEventFor, assertNotLeaving, } from './actions-dom.js';
 import { scrollFrom } from './scroll.js';
+import { clickHitsNoControl } from './click-target.js';
 function enabledOf(el) {
     return !getStates(el).includes(ElementState.DISABLED);
 }
@@ -209,7 +168,8 @@ async function dispatchOther(el, action, args) {
                         'To empty a field on purpose use the `clear` action, or fill with an explicit "".');
                 }
                 assertEditable(el, 'fill');
-                el.focus();
+                if (!isAutofillSafeTarget(el))
+                    el.focus();
                 return setNativeValue(el, args['value']);
             }
             assertNotRichText(el, 'fill');
@@ -235,8 +195,8 @@ async function dispatchOther(el, action, args) {
                 if (typeof args['value'] !== 'string') {
                     throw new Error("select requires a string `value` — pass it nested, as args: { value: '…' }.");
                 }
-                const wanted = args['value'];
                 const options = Array.from(el.options);
+                const wanted = optionValueFor(options, args['value']);
                 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}`);
@@ -287,6 +247,8 @@ async function dispatchOther(el, action, args) {
             const code = pressCode(args, key);
             const down = asSyntheticInput(() => el.dispatchEvent(keyboardEvent('keydown', { key, code, bubbles: true, cancelable: true, ...mods })));
             closeModalOnEscape(el, key, down);
+            if (down)
+                dispatchKeypress(el, key, code, mods);
             const hold = clampHoldMs(args['holdMs']);
             if (hold > 0)
                 await holdKey(el, key, code, mods, hold);
@@ -344,24 +306,22 @@ async function dispatchOther(el, action, args) {
             throw new Error(`unknown action '${action}'`);
     }
 }
-function asSettleBudget(raw) {
-    if ('number' !== typeof raw || !Number.isFinite(raw))
-        return undefined;
-    return Math.max(0, Math.min(raw, FRAME_BUDGET_MS_CEILING));
-}
-const FRAME_BUDGET_MS_CEILING = 200;
 export async function executeAction(ref, action, args = {}) {
     const named = 0 < ref.length;
     const el = isReflessDocumentPress(ref, action, args) ? focusedOrDocument() : requireElement(ref);
     if (named)
         assertActionAllowed(el, action, args);
+    if (named)
+        assertNotLeaving(el);
     const anchor = named ? anchorOf(el) : {};
     const visible = isVisible(el);
     const enabled = enabledOf(el);
     const prevFocus = activeRef(el);
     const valueBefore = valueOf(el);
+    const actedField = watchActedField(el);
     const geometry = CLICK_LIKE.has(action) ? clickGeometry(el) : NO_GEOMETRY;
     const alreadyAtValue = alreadyAtCheckedState(el, action);
+    const hitsNoControl = clickHitsNoControl(el, action);
     let mutated = 0;
     const said = new AppearedText();
     const obs = new MutationObserver((records) => {
@@ -389,9 +349,11 @@ export async function executeAction(ref, action, args = {}) {
         settled = outcome.settled;
         settleReason = outcome.settled ? null : SettleReason.TIMEOUT;
         obs.disconnect();
+        actedField?.stop();
     }
     assertAriaToggleLanded(el, action, alreadyAtValue);
     const valueAfter = valueOf(el);
+    publishSettledField(el, actedField);
     const nextFocus = activeRef(el);
     const effect = {
         dispatched: true,
@@ -401,13 +363,18 @@ export async function executeAction(ref, action, args = {}) {
         defaultPrevented,
         focusMoved: prevFocus !== nextFocus ? `${prevFocus ?? 'null'}->${nextFocus ?? 'null'}` : null,
         valueChanged: isFillLike(action) ? valueBefore !== valueAfter : false,
+        ...(ActionType.FILL === action && isAutofillSafeTarget(el) ? { autofillSafe: true } : {}),
         domMutatedWithin: mutated,
         ...said.effect(valueAfter),
         occluded: geometry.occluded,
         occludedBy: geometry.occludedBy,
         scrolledIntoView: geometry.scrolledIntoView,
+        ...(geometry.occluderName === undefined ? {} : { occluderName: geometry.occluderName }),
+        ...(true === geometry.noSize ? { noSize: true } : {}),
+        ...(true === geometry.offViewport ? { offViewport: true } : {}),
         ...(heldMs > 0 ? { heldMs } : {}),
         ...(alreadyAtValue ? { alreadyAtValue: true } : {}),
+        ...canvasesOnScreen(),
     };
     const warning = !named
         ? ActionWarning.GLOBAL_PRESS
@@ -415,8 +382,15 @@ export async function executeAction(ref, action, args = {}) {
             ? ActionWarning.CLICK_OCCLUDED
             : action === ActionType.HOVER && elementHasHoverHandlers(el)
                 ? ActionWarning.HOVER_NATIVE_ENTER_LEAVE
-                : undefined;
-    return result(ref, action, effect, settled, settleReason, anchor, warning);
+                : hitsNoControl
+                    ? ActionWarning.CLICK_NOT_A_CONTROL
+                    : undefined;
+    const done = result(ref, action, effect, settled, settleReason, anchor, warning);
+    return isReticleUi(el) ? { ...done, reticleUi: true } : done;
+}
+function canvasesOnScreen() {
+    const canvases = visibleCanvases(document);
+    return canvases > 0 ? { canvases } : {};
 }
 const sleep = (ms) => new Promise((r) => nativeSetTimeout(r, ms));
 export async function executeSequence(steps) {
@@ -442,6 +416,8 @@ export async function executeSequence(steps) {
             stepBase.name = res.name;
         if (res.source !== undefined)
             stepBase.source = res.source;
+        if (res.secret !== undefined)
+            stepBase.secret = res.secret;
         if (res.warning !== undefined)
             stepBase.warning = res.warning;
         stepResults.push(stepBase);

package/dist/actions/appeared-text.js

@@ -1,4 +1,5 @@
-import { isIgnored } from '../dom/dom-ignore.js';
+import { isWordsIgnored } from '../dom/dom-ignore.js';
+import { isSensitiveField } from '../dom/a11y.js';
 const APPEARED_MAX = 200;
 const JOIN = ' | ';
 const TEXT_NODE = 3;
@@ -44,7 +45,9 @@ export class AppearedText {
         return this.#length > APPEARED_MAX;
     }
     #add(raw, owner) {
-        if (null !== owner && isIgnored(owner))
+        if (null !== owner && isWordsIgnored(owner))
+            return;
+        if (null !== owner && isSensitiveField(owner))
             return;
         const text = (raw ?? '').replace(/\s+/g, ' ').trim();
         if (0 === text.length)

package/dist/actions/click-target.d.ts

@@ -0,0 +1 @@
+export declare function clickHitsNoControl(el: Element, action: string): boolean;

package/dist/actions/click-target.js

@@ -0,0 +1,14 @@
+import { ActionType } from '@reticlehq/core';
+import { getRole } from '../dom/a11y.js';
+import { parentAcrossShadowBoundary } from '../dom/shadow-registry.js';
+import { INTERACTIVE } from '../dom/snapshot.js';
+const CLICK_FORWARDING = 'label, summary, [onclick], [tabindex], [contenteditable]:not([contenteditable="false"])';
+export function clickHitsNoControl(el, action) {
+    if (ActionType.CLICK !== action && ActionType.DBLCLICK !== action)
+        return false;
+    for (let node = el; node !== null; node = parentAcrossShadowBoundary(node)) {
+        if (INTERACTIVE.has(getRole(node)) || node.matches(CLICK_FORWARDING))
+            return false;
+    }
+    return 'pointer' !== getComputedStyle(el).cursor;
+}

package/dist/actions/danger-context.d.ts

@@ -1,4 +1,7 @@
 import { type ActionTarget } from '../dom/realm.js';
 export declare function dangerousActionContext(el: ActionTarget): string;
 export declare function submitControlFor(el: ActionTarget): HTMLElement | null;
-export declare function requiresDangerousConfirmation(text: string, role?: string): boolean;
+export declare function requiresDangerousConfirmation(el: ActionTarget): boolean;
+export declare function setOutwardPolicy(allowed: readonly string[] | undefined): void;
+export declare function assertOutwardAllowed(targets: readonly (ActionTarget | null)[]): void;
+export declare function assertPaymentEntryAllowed(el: ActionTarget): void;