react-native-tapline 0.0.0-stage → 1.0.0

package/dist/actions.js

@@ -0,0 +1,1883 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tree = void 0;
+exports.configureActions = configureActions;
+exports.onActed = onActed;
+exports.settle = settle;
+exports.settleOutcome = settleOutcome;
+exports.parseTarget = parseTarget;
+exports.labelOf = labelOf;
+exports.resolveTarget = resolveTarget;
+exports.describeHit = describeHit;
+exports.back = back;
+exports.press = press;
+exports.longPress = longPress;
+exports.setKeyboardControl = setKeyboardControl;
+exports.typeText = typeText;
+exports.scroll = scroll;
+exports.toggle = toggle;
+exports.openURL = openURL;
+exports.getLogs = getLogs;
+exports.reload = reload;
+exports.screenshotAvailable = screenshotAvailable;
+exports.screenshot = screenshot;
+exports.swipe = swipe;
+const react_native_1 = require("react-native");
+const keyboard_1 = require("./keyboard");
+const native_1 = require("./native");
+const inspect_1 = require("./inspect");
+const alerts_1 = require("./alerts");
+const fiber_1 = require("./fiber");
+const logs_1 = require("./logs");
+const register_1 = require("./register");
+const settle_1 = require("./settle");
+const types_1 = require("./types");
+var inspect_2 = require("./inspect");
+Object.defineProperty(exports, "tree", { enumerable: true, get: function () { return inspect_2.tree; } });
+/** What follows `disabled`: `force` never acts on a disabled element (the check comes first), so the app has to enable it. */
+const ENABLE_FIRST = 'the app has to enable it first (force doesn\'t apply)';
+function notActionable(reason, message) {
+    return new types_1.TaplineError('not_actionable', `${reason}: ${message}`);
+}
+/**
+ * Runs the checks for what a person could do. Without `force` a refusal is thrown as usual. With
+ * it the checks still run, and what they would have refused comes back as `{ forced: <reason> }`,
+ * so the answer can say that a person couldn't have done this (AGENT-TOOLS v1.6). Anything else
+ * that goes wrong inside a forced check is ignored: `force` means "act anyway".
+ */
+async function checkedOrForced(force, check) {
+    if (!force) {
+        await check();
+        return {};
+    }
+    try {
+        await check();
+    }
+    catch (error) {
+        if (error instanceof types_1.TaplineError && error.code === 'not_actionable') {
+            return { forced: error.message.slice(0, Math.max(0, error.message.indexOf(':'))) || 'not_actionable' };
+        }
+    }
+    return {};
+}
+const settings = { quietMs: 100, capMs: 2000 };
+/** Tune how long the app must be free of React commits after an action, and the longest wait (AGENT-TOOLS §6). */
+function configureActions(next) {
+    if (typeof next.quietMs === 'number')
+        settings.quietMs = next.quietMs;
+    if (typeof next.capMs === 'number')
+        settings.capMs = next.capMs;
+}
+const actedListeners = new Set();
+/** Runs `listener` when an action's handler has run, before the wait for the app to settle. */
+function onActed(listener) {
+    actedListeners.add(listener);
+    return () => {
+        actedListeners.delete(listener);
+    };
+}
+function notifyActed() {
+    for (const listener of [...actedListeners]) {
+        try {
+            listener();
+        }
+        catch {
+            // a listener must never break the action
+        }
+    }
+}
+/** Waits until the app is still after an action; resolves with the milliseconds that took. */
+async function settle() {
+    notifyActed();
+    return (await settleNow()).settledMs;
+}
+/** Like `settle`, and says when the wait ended at the cap: spread it into an action's result. */
+async function settleOutcome() {
+    notifyActed();
+    return settleNow();
+}
+const SHEET_POLL_MS = 100;
+/** Whether `fiber` sits inside `host`. */
+function isInside(fiber, host) {
+    for (let up = fiber.return; up; up = up.return)
+        if ((0, fiber_1.sameFiber)(up, host))
+            return true;
+    return false;
+}
+/** The fiber to watch in the top open modal: its first element with an action, else its first framed host. */
+async function sheetProbe() {
+    const hosts = (0, inspect_1.openModalHosts)();
+    const top = hosts[hosts.length - 1];
+    if (!top)
+        return null;
+    const inside = (0, inspect_1.takeSnapshot)().entries.filter((entry) => isInside(entry.node.fiber, top));
+    const acting = inside.find((entry) => entry.info.actions.length > 0);
+    if (acting)
+        return acting.node.fiber;
+    for (const entry of inside) {
+        const frame = await (0, inspect_1.measureFiber)(entry.node.fiber);
+        if (frame && frame.width > 0 && frame.height > 0)
+            return entry.node.fiber;
+    }
+    return null;
+}
+async function settleNow() {
+    const started = Date.now();
+    let capped = false;
+    const onCap = () => {
+        capped = true;
+    };
+    await (0, settle_1.waitUntilStill)({
+        ...settings,
+        onCommit: (listener) => (0, register_1.onCommit)(() => listener()),
+        now: Date.now,
+        onCap,
+    });
+    const left = settings.capMs - (Date.now() - started);
+    if (left > 0) {
+        // A sheet lifted by a native-driver animation makes no commits: wait for it to stop moving.
+        const probe = await sheetProbe().catch(() => null);
+        if (probe)
+            await (0, settle_1.waitUntilSteady)(() => (0, inspect_1.measureFiber)(probe), { pollMs: SHEET_POLL_MS, capMs: left, now: Date.now, onCap });
+    }
+    // A sheet being dismissed stays mounted (and covering the screen) until iOS ends the animation.
+    if ((0, inspect_1.closingModalHosts)().length > 0) {
+        while ((0, inspect_1.closingModalHosts)().length > 0) {
+            const remaining = settings.capMs - (Date.now() - started);
+            if (remaining <= 0) {
+                capped = true;
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, Math.min(SHEET_POLL_MS, remaining)));
+        }
+        // Unmounting the modal commits: let the app go quiet again, within the cap.
+        const afterwards = settings.capMs - (Date.now() - started);
+        if (afterwards > 0) {
+            await (0, settle_1.waitUntilStill)({
+                quietMs: settings.quietMs,
+                capMs: afterwards,
+                onCommit: (listener) => (0, register_1.onCommit)(() => listener()),
+                now: Date.now,
+                onCap,
+            });
+        }
+    }
+    const settledMs = Math.max(0, Math.min(settings.capMs, Date.now() - started));
+    return capped && settings.capMs > 0 ? { settledMs, settleCapMs: settings.capMs } : { settledMs };
+}
+function badParams(message) {
+    return new types_1.TaplineError('bad_params', message);
+}
+function paramsOf(raw) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (!(0, types_1.isRecord)(raw))
+        throw badParams('params must be an object');
+    return raw;
+}
+/** An element as element lines name it: `e6 button "Continue"`, or `id=<testID>` without text or label. */
+function describe(entry, maxText = inspect_1.MAX_TEXT) {
+    const { info } = entry;
+    const shown = (0, inspect_1.cutText)(info.text !== '' ? info.text : (info.label ?? ''), 0, maxText);
+    const name = shown !== '' ? `"${shown}"` : info.testID ? `id=${info.testID}` : '';
+    return [(0, inspect_1.refFor)(entry.node.fiber), (0, inspect_1.roleName)(info), name].filter((part) => part !== '').join(' ');
+}
+/** Call an app handler; sync throws become errors, async rejections are logged not awaited. */
+function callHandler(name, handler, args) {
+    let result;
+    try {
+        result = handler(...args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new types_1.TaplineError('internal', `${name} threw: ${message}`);
+    }
+    if ((0, types_1.isRecord)(result) && typeof result.then === 'function') {
+        result.then(undefined, (error) => {
+            console.error(`[tapline] ${name} rejected:`, error);
+        });
+    }
+}
+function parseTarget(raw) {
+    if (!(0, types_1.isRecord)(raw))
+        throw badParams('target must be an object such as {"testID":"login"}');
+    let index;
+    if (raw.index !== undefined) {
+        if (typeof raw.index !== 'number' || !Number.isInteger(raw.index) || raw.index < 0) {
+            throw badParams('target.index must be a non-negative integer');
+        }
+        index = raw.index;
+    }
+    const kinds = [];
+    const withIndex = (target) => (index === undefined ? target : { ...target, index });
+    if (raw.ref !== undefined) {
+        if (typeof raw.ref !== 'string')
+            throw badParams('target.ref must be a string');
+        kinds.push(withIndex({ kind: 'ref', ref: raw.ref }));
+    }
+    for (const key of ['testID', 'label', 'text']) {
+        const value = raw[key];
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'string')
+            throw badParams(`target.${key} must be a string`);
+        // Invisible direction marks never match: strip them from what the agent typed, as the list does.
+        kinds.push(withIndex({ kind: key, value: key === 'testID' ? value : (0, inspect_1.displayText)(value) }));
+    }
+    if (raw.x !== undefined || raw.y !== undefined) {
+        if (typeof raw.x !== 'number' || typeof raw.y !== 'number') {
+            throw badParams('target.x and target.y must both be numbers');
+        }
+        kinds.push(withIndex({ kind: 'point', x: raw.x, y: raw.y }));
+    }
+    const first = kinds[0];
+    if (!first)
+        throw badParams('target needs one of: ref, testID, label, text, or x and y');
+    if (kinds.length > 1)
+        throw badParams('target must have exactly one of: ref, testID, label, text, x+y');
+    return first;
+}
+function isAncestor(snapshot, ancestor, descendant) {
+    for (let p = descendant.node.parent; p >= 0;) {
+        if (p === ancestor.node.index)
+            return true;
+        const next = snapshot.nodes[p];
+        if (!next)
+            return false;
+        p = next.parent;
+    }
+    return false;
+}
+/**
+ * Collapse matches that are the same thing seen at two levels of the host tree.
+ * 'outer': props like testID propagate down, keep the outermost.
+ * 'text': keep the actionable one, otherwise the innermost.
+ */
+function dedupe(snapshot, matches, mode) {
+    const drop = new Set();
+    for (const a of matches) {
+        for (const b of matches) {
+            if (a === b || !isAncestor(snapshot, a, b))
+                continue;
+            if (mode === 'outer') {
+                drop.add(b);
+            }
+            else {
+                // A container that only scrolls is not a target: its text is its children's text joined.
+                const aActs = a.info.actions.some((action) => action !== 'scroll');
+                const bActs = b.info.actions.some((action) => action !== 'scroll');
+                if (aActs && !bActs)
+                    drop.add(b);
+                else if (!aActs)
+                    drop.add(a);
+            }
+        }
+    }
+    return matches.filter((match) => !drop.has(match));
+}
+function describeTarget(target) {
+    switch (target.kind) {
+        case 'ref':
+            return `ref "${target.ref}"`;
+        case 'point':
+            return `point (${target.x}, ${target.y})`;
+        case 'testID':
+            return `id "${target.value}"`;
+        default:
+            return `${target.kind} "${target.value}"`;
+    }
+}
+/** AGENT-TOOLS §4: what a `not_found` says, per kind of target. */
+function notFoundMessage(target) {
+    switch (target.kind) {
+        case 'testID':
+            return `nothing on screen has id "${target.value}"; look, then pick another target.`;
+        case 'label':
+            return `nothing on screen has label "${target.value}"; use {text} for a partial match, or look.`;
+        case 'text':
+            return `nothing on screen shows "${target.value}"; look, then pick another target.`;
+        case 'ref':
+            return `${target.ref} isn't on screen any more; look again.`;
+        case 'point':
+            return `nothing on screen at (${target.x}, ${target.y}); look, then pick another target.`;
+    }
+}
+/**
+ * What a `label` target matches: the element's own accessibility label, else its text. iOS forms
+ * the label of an element that has none from the text inside it, and Tapwright reads that label, so
+ * `{label: "OK"}` finds a button that only shows "OK" in both tools.
+ */
+function labelOf(info) {
+    return info.label ?? info.text;
+}
+function matchEntries(snapshot, target) {
+    const pool = snapshot.entries.filter((entry) => entry.info.interesting);
+    switch (target.kind) {
+        case 'testID':
+            return dedupe(snapshot, pool.filter((e) => e.info.testID === target.value), 'outer');
+        case 'label': {
+            const wanted = target.value.trim().toLowerCase();
+            if (wanted === '')
+                return [];
+            return dedupe(snapshot, pool.filter((e) => labelOf(e.info).toLowerCase() === wanted), 'outer');
+        }
+        case 'text': {
+            const wanted = target.value.replace(/\s+/g, ' ').trim().toLowerCase();
+            if (wanted === '')
+                return [];
+            const exact = pool.filter((e) => e.info.text.toLowerCase() === wanted);
+            if (exact.length > 0)
+                return dedupe(snapshot, exact, 'text');
+            return dedupe(snapshot, pool.filter((e) => e.info.text.toLowerCase().includes(wanted)), 'text');
+        }
+        default:
+            return [];
+    }
+}
+/** What a point takes, as `Nothing at (x, y) takes <this>.` reads (AGENT-TOOLS §4). */
+const HINT_VERBS = {
+    press: 'a tap',
+    longPress: 'a long press',
+    toggle: 'a toggle',
+    scroll: 'a scroll',
+    type: 'typing',
+};
+/** The candidates of an `ambiguous` error as full elements, so the agent sees role, id, actions and place. */
+async function candidateElements(entries) {
+    const frames = await Promise.all(entries.map((entry) => (0, inspect_1.measureFiber)(entry.node.fiber)));
+    return entries.map((entry, i) => (0, inspect_1.toElement)(entry, entry.tab ? null : (frames[i] ?? null)));
+}
+/** How far from the left edge the native navigation bar's back button reaches, in points. */
+const BACK_BUTTON_WIDTH = 100;
+/** A stand-in fiber for the navigation bar's back button, which iOS draws outside React's tree. */
+const backButtonFiber = {
+    tag: -1,
+    type: 'BackButton',
+    elementType: 'BackButton',
+    memoizedProps: {},
+    stateNode: null,
+    child: null,
+    sibling: null,
+    return: null,
+    alternate: null,
+};
+function backButtonEntry(snapshot) {
+    const node = {
+        index: snapshot.nodes.length,
+        parent: -1,
+        fiber: backButtonFiber,
+        hostType: 'BackButton',
+        owners: [],
+        text: 'Back',
+        isText: false,
+        insideText: false,
+    };
+    return {
+        node,
+        navBack: true,
+        info: {
+            type: 'BackButton',
+            role: 'button',
+            testID: null,
+            label: 'Back',
+            text: 'Back',
+            value: null,
+            placeholder: null,
+            actions: ['press'],
+            disabled: false,
+            selected: false,
+            checked: null,
+            interesting: true,
+        },
+    };
+}
+/** An element as the list words it: `[ref ]role "text" id=… @x,y WxH` (the position only when its frame is known). */
+function elementLine(entry, frame, withRef) {
+    const { info } = entry;
+    const shown = (0, inspect_1.cutText)(info.text !== '' ? info.text : (info.label ?? ''));
+    return [
+        withRef ? (0, inspect_1.refFor)(entry.node.fiber) : '',
+        (0, inspect_1.roleName)(info),
+        shown !== '' ? `"${shown}"` : '',
+        info.testID ? `id=${info.testID}` : '',
+        frame ? `@${Math.round(frame.x)},${Math.round(frame.y)} ${Math.round(frame.width)}x${Math.round(frame.height)}` : '',
+    ]
+        .filter((part) => part !== '')
+        .join(' ');
+}
+/**
+ * AGENT-TOOLS v1.4: a target that matches nothing in the list, but matches an element only hidden
+ * because an open sheet covers its screen, is `covered`, not `not_found`. The answer names what is
+ * in front (with its ref, so the agent can act on it); `force` doesn't help, the element isn't on
+ * the list. An OS alert still answers `behind_alert` first. Returns when nothing hidden matches.
+ */
+async function refuseBehindSheet(snapshot, target) {
+    const behind = snapshot.behind?.();
+    if (!behind)
+        return;
+    const matches = matchEntries({ ...snapshot, nodes: behind.nodes, entries: behind.hidden }, target);
+    const hidden = matches[target.index ?? 0];
+    if (!hidden)
+        return;
+    assertNoBlockingAlert();
+    const [hiddenFrame, inFront] = await Promise.all([(0, inspect_1.measureFiber)(hidden.node.fiber), frontLine(snapshot)]);
+    throw notActionable('covered', `${elementLine(hidden, hiddenFrame, false)} is behind ${inFront ?? 'the open sheet'}; close that first.`);
+}
+/**
+ * The line of the first element in front that has a text or an id (with its ref, so the agent can
+ * act on it): what names an open sheet in an answer. Undefined when nothing in front has either.
+ */
+async function frontLine(snapshot) {
+    const front = snapshot.entries.find((entry) => entry.info.interesting && !entry.tab && (entry.info.text.trim() !== '' || entry.info.testID));
+    return front ? elementLine(front, await (0, inspect_1.measureFiber)(front.node.fiber), true) : undefined;
+}
+/**
+ * AGENT-TOOLS v1.5: when several elements match a target and some of them are in the alert that is
+ * in front, only those count; a person sees one "Cancel", not the one behind the alert too. With no
+ * match in the alert the list is left alone, so a target behind it still answers `behind_alert`.
+ * (What an open sheet hides isn't in the list at all, so a sheet needs no such rule.)
+ */
+function inFrontLayer(matches) {
+    if (matches.length < 2 || !(0, alerts_1.openAlerts)().some((alert) => alert.standIn))
+        return matches;
+    const inAlert = matches.filter((entry) => inStandInAlert(entry.node.fiber));
+    return inAlert.length > 0 ? inAlert : matches;
+}
+/** Resolve a protocol target to exactly one element, or throw not_found / ambiguous. */
+async function resolveTarget(raw, hint) {
+    const target = parseTarget(raw);
+    const snapshot = (0, inspect_1.takeSnapshot)();
+    if (target.kind === 'ref') {
+        const fiber = (0, inspect_1.fiberForRef)(target.ref);
+        const entry = fiber ? snapshot.entries.find((e) => (0, fiber_1.sameFiber)(e.node.fiber, fiber)) : undefined;
+        if (!entry)
+            throw new types_1.TaplineError('not_found', notFoundMessage(target));
+        return { snapshot, entry };
+    }
+    if (target.kind === 'point') {
+        // iOS draws the native tab bar over the app: a touch there lands on a tab, not on what's behind.
+        const bar = (0, inspect_1.nativeTabBar)(snapshot);
+        const tab = bar && target.y >= bar.top ? (0, inspect_1.tabAt)(bar, target.x, snapshot.screen.width) : undefined;
+        if (tab)
+            return { snapshot, entry: tab };
+        // Likewise the navigation bar at the top: a touch there hits the bar, unless it lands on one of
+        // the custom items the app put in the header.
+        const navBar = (0, inspect_1.nativeNavBar)(snapshot);
+        if (navBar && target.y < navBar.bottom) {
+            const inHeader = snapshot.entries.filter((e) => !e.tab && (0, inspect_1.inNavBarHeader)(navBar, e.node.fiber));
+            const headerFrames = await Promise.all(inHeader.map((e) => (0, inspect_1.measureFiber)(e.node.fiber)));
+            const onItem = headerFrames.some((frame) => frame !== null && (0, inspect_1.frameContains)(frame, target.x, target.y));
+            if (!onItem) {
+                if (navBar.canGoBack && target.x < BACK_BUTTON_WIDTH && (hint === undefined || hint === 'press')) {
+                    return { snapshot, entry: backButtonEntry(snapshot) };
+                }
+                throw notActionable('no_action', `Nothing at (${target.x}, ${target.y}) takes ${hint === undefined ? 'a touch' : HINT_VERBS[hint]}: it's on the navigation bar iOS draws.`);
+            }
+        }
+        const actionable = snapshot.entries.filter((e) => hint === undefined ? e.info.actions.length > 0 : e.info.actions.includes(hint));
+        const frames = await Promise.all(actionable.map((e) => (0, inspect_1.measureFiber)(e.node.fiber)));
+        let hit;
+        actionable.forEach((entry, i) => {
+            const frame = frames[i];
+            if (frame && (0, inspect_1.frameContains)(frame, target.x, target.y))
+                hit = entry; // later in tree order = in front
+        });
+        if (!hit) {
+            const verb = hint === undefined ? 'a touch' : HINT_VERBS[hint];
+            throw notActionable('no_action', `Nothing at (${target.x}, ${target.y}) takes ${verb}.`);
+        }
+        return { snapshot, entry: hit };
+    }
+    const matches = inFrontLayer(matchEntries(snapshot, target));
+    if (matches.length === 0)
+        await refuseBehindSheet(snapshot, target);
+    if (target.index !== undefined) {
+        const picked = matches[target.index];
+        if (!picked) {
+            throw new types_1.TaplineError('not_found', `Only ${matches.length} element(s) match ${describeTarget(target)}; index ${target.index} is out of range`);
+        }
+        return { snapshot, entry: picked };
+    }
+    const [only, ...rest] = matches;
+    if (!only)
+        throw new types_1.TaplineError('not_found', notFoundMessage(target));
+    if (rest.length > 0) {
+        const shown = matches.slice(0, 5);
+        throw new types_1.TaplineError('ambiguous', `${matches.length} elements match ${describeTarget(target)}.`, shown.map((entry) => (0, inspect_1.refFor)(entry.node.fiber)), await candidateElements(shown));
+    }
+    return { snapshot, entry: only };
+}
+/** The entry itself, else the nearest ancestor that offers `action`. */
+function selfOrAncestor(snapshot, entry, action) {
+    for (let node = entry.node;;) {
+        const candidate = snapshot.entries[node.index];
+        if (candidate?.info.actions.includes(action))
+            return candidate;
+        if (node.parent < 0)
+            return null;
+        const parent = snapshot.nodes[node.parent];
+        if (!parent)
+            return null;
+        node = parent;
+    }
+}
+function descendantsWith(snapshot, entry, action) {
+    return snapshot.entries.filter((candidate) => candidate.info.actions.includes(action) && isAncestor(snapshot, entry, candidate));
+}
+/** Self, then ancestors, then a single descendant offering `action`. */
+function findActionable(snapshot, entry, action, descend) {
+    const up = selfOrAncestor(snapshot, entry, action);
+    if (up)
+        return up;
+    if (!descend)
+        return null;
+    const down = descendantsWith(snapshot, entry, action);
+    return down.length === 1 ? (down[0] ?? null) : null;
+}
+async function elementFor(entry, knownFrame) {
+    const frame = knownFrame !== undefined ? knownFrame : await (0, inspect_1.measureFiber)(entry.node.fiber);
+    return { element: (0, inspect_1.toElement)(entry, frame), frame };
+}
+/* -------------------------------------------------------------------------- */
+/* press / longPress                                                           */
+/* -------------------------------------------------------------------------- */
+function nativeTagOf(fiber) {
+    const state = fiber.stateNode;
+    if ((0, types_1.isRecord)(state)) {
+        if (typeof state._nativeTag === 'number')
+            return state._nativeTag;
+        const canonical = state.canonical;
+        if ((0, types_1.isRecord)(canonical) && typeof canonical.nativeTag === 'number')
+            return canonical.nativeTag;
+    }
+    return 0;
+}
+function pressEvent(fiber, frame) {
+    const width = frame?.width ?? 0;
+    const height = frame?.height ?? 0;
+    const pageX = (frame?.x ?? 0) + width / 2;
+    const pageY = (frame?.y ?? 0) + height / 2;
+    const timestamp = Date.now();
+    const target = nativeTagOf(fiber);
+    const nativeEvent = {
+        locationX: width / 2,
+        locationY: height / 2,
+        pageX,
+        pageY,
+        timestamp,
+        target,
+        identifier: 0,
+        touches: [],
+        changedTouches: [],
+    };
+    return {
+        nativeEvent,
+        target,
+        currentTarget: target,
+        type: 'press',
+        timeStamp: timestamp,
+        bubbles: true,
+        cancelable: true,
+        defaultPrevented: false,
+        persist: () => { },
+        preventDefault: () => { },
+        stopPropagation: () => { },
+        isDefaultPrevented: () => false,
+        isPropagationStopped: () => false,
+    };
+}
+/** The nearest listed element at or above a host fiber, for naming what covers a target. */
+function describeHit(snapshot, hit, actor) {
+    for (let fiber = hit; fiber; fiber = fiber.return) {
+        const entry = snapshot.entries.find((candidate) => candidate.info.interesting && (0, fiber_1.sameFiber)(candidate.node.fiber, fiber));
+        if (entry) {
+            return describe(entry, 40);
+        }
+    }
+    // Never a native type name ("RCTView"): the agent can't act on it.
+    const modal = (0, inspect_1.openModalHosts)().find((host) => (0, inspect_1.isWithin)(hit, host));
+    if (modal && !(actor && (0, inspect_1.isWithin)(actor.node.fiber, modal))) {
+        const inside = snapshot.entries.filter((e) => e.info.interesting && !e.tab && (0, inspect_1.isWithin)(e.node.fiber, modal));
+        const named = inside.find((e) => e.info.actions.length > 0) ?? inside[0];
+        return named ? `an open modal (${describe(named, 40)})` : 'an open modal';
+    }
+    return 'another view';
+}
+/** The part of an element a person can touch must be at least this wide and high. */
+const MIN_VISIBLE_PT = 10;
+/** How many covers are cut away from an element before giving up. */
+const MAX_COVER_CUTS = 4;
+/** `box` without `cut`: the largest of the strips above, below, left and right of it; null when nothing is left. */
+function withoutBox(box, cut) {
+    if (box === null)
+        return null;
+    if (cut.right <= box.left || cut.left >= box.right || cut.bottom <= box.top || cut.top >= box.bottom)
+        return box;
+    const strips = [
+        { ...box, bottom: Math.min(box.bottom, cut.top) },
+        { ...box, top: Math.max(box.top, cut.bottom) },
+        { ...box, right: Math.min(box.right, cut.left) },
+        { ...box, left: Math.max(box.left, cut.right) },
+    ];
+    let best = null;
+    let bestArea = 0;
+    for (const strip of strips) {
+        const area = Math.max(0, strip.right - strip.left) * Math.max(0, strip.bottom - strip.top);
+        if (area > bestArea) {
+            best = strip;
+            bestArea = area;
+        }
+    }
+    return best;
+}
+/** The testID of the view Tapline's in-app alert draws (`TaplineAlertHost`); its buttons and input sit inside it. */
+const STAND_IN_ALERT_ID = 'tapline-alert';
+/** Whether a fiber is inside the stand-in alert's own view. */
+function inStandInAlert(fiber) {
+    for (let up = fiber; up; up = up.return) {
+        const props = up.memoizedProps;
+        if ((0, types_1.isRecord)(props) && props.testID === STAND_IN_ALERT_ID)
+            return true;
+    }
+    return false;
+}
+/**
+ * An alert sits on top of everything: a person has to answer it first. An OS alert can't be pressed
+ * from here; Tapline's stand-in covers the whole screen, so anything outside it is behind it, and
+ * its own buttons are what to tap. `actor` is the element about to be touched, when there is one.
+ */
+function assertNoBlockingAlert(actor) {
+    const blocking = (0, alerts_1.openAlerts)().find((alert) => !alert.standIn);
+    if (blocking) {
+        const buttons = blocking.buttons.map((button) => `[${button.text}]`).join(' ');
+        if ((0, alerts_1.isOwnAlert)(blocking.id)) {
+            throw notActionable('behind_alert', `Tapline's own prompt is open: "${blocking.title}" ${buttons}. Only the person holding the phone answers it: ` +
+                'ask the user to tap a button. force: true acts anyway.');
+        }
+        throw notActionable('behind_alert', `An alert is open: "${blocking.title}" ${buttons}. A person would have to answer it first, and Tapline can't press OS alerts: ` +
+            "ask the user to tap a button, or start Tapline with alerts: 'stand-in' so its buttons can be pressed. force: true acts anyway.");
+    }
+    const standIn = (0, alerts_1.openAlerts)().find((alert) => alert.standIn);
+    if (standIn && !(actor && inStandInAlert(actor.node.fiber))) {
+        const buttons = standIn.buttons.map((button) => `[${button.text}]`).join(' ');
+        throw notActionable('behind_alert', `"${standIn.title}" is open with ${buttons}; tap one of them first.`);
+    }
+}
+/** How a refusal names the one call that brings an element onto the screen (AGENT-TOOLS v1.6, shared with Tapwright). */
+const SCROLL_TO_TARGET_HINT = '(scroll with this target and to: "target")';
+/**
+ * Refuses what a person couldn't tap: an element off screen, or one with something else on top
+ * at the centre of its visible part (Fabric's hit test). Unknown hit results let it through.
+ */
+async function assertReachable(snapshot, actor, frame) {
+    assertNoBlockingAlert(actor);
+    if (frame === null)
+        return;
+    const { width, height } = snapshot.screen;
+    const left = Math.max(frame.x, 0);
+    const top = Math.max(frame.y, 0);
+    const right = Math.min(frame.x + frame.width, width);
+    const bottom = Math.min(frame.y + frame.height, height);
+    const name = describe(actor);
+    if (right <= left || bottom <= top) {
+        throw notActionable('off_screen', `${name} is off screen (at ${Math.round(frame.x)},${Math.round(frame.y)}; the screen is ${width}x${height}). ` +
+            `Scroll to it first ${SCROLL_TO_TARGET_HINT}, or pass force: true to call its handler anyway.`);
+    }
+    const bar = (0, inspect_1.nativeTabBar)(snapshot);
+    const navBar = (0, inspect_1.nativeNavBar)(snapshot);
+    const underNavBar = (y) => navBar !== null && y < navBar.bottom && !(0, inspect_1.inNavBarHeader)(navBar, actor.node.fiber);
+    // The last hit test, so a point is never asked twice.
+    let asked = null;
+    const hitAt = async (x, y) => {
+        if (asked && asked.x === x && asked.y === y)
+            return asked.hit;
+        const hit = await (0, inspect_1.hitTest)(x, y);
+        asked = { x, y, hit };
+        return hit;
+    };
+    // Why a touch at (x, y) would not reach the actor, or null when it would (an unknown hit lets it through).
+    const refusalAt = async (x, y) => {
+        if (bar && y >= bar.top) {
+            return notActionable('under_tab_bar', `${name} is under the tab bar iOS draws, at (${x}, ${y}): a real tap would switch tabs instead. ` +
+                `Scroll it clear of the bar ${SCROLL_TO_TARGET_HINT}, or pass force: true to call its handler anyway.`);
+        }
+        if (underNavBar(y)) {
+            return notActionable('covered', `${name} is under the navigation bar iOS draws, at (${x}, ${y}): a real tap would hit the bar instead. ` +
+                `Scroll it clear of the bar ${SCROLL_TO_TARGET_HINT}, or pass force: true to call its handler anyway.`);
+        }
+        const hit = await hitAt(x, y);
+        if (!hit || (0, inspect_1.isWithin)(hit, actor.node.fiber) || (0, inspect_1.isWithin)(actor.node.fiber, hit))
+            return null;
+        return notActionable('covered', `${name} is covered at (${x}, ${y}) by ${describeHit(snapshot, hit, actor)}: a real tap would land there instead. ` +
+            'Dismiss or scroll it out of the way, or pass force: true to call the handler anyway.');
+    };
+    const refusal = await refusalAt(Math.round((left + right) / 2), Math.round((top + bottom) / 2));
+    if (refusal === null)
+        return;
+    // Touch the visible part (AGENT-TOOLS v1.3): what's left of the element outside the bars and
+    // covers, if it is at least 10 x 10 pt, is touched at its centre, as a finger would.
+    let part = { left, top, right, bottom };
+    if (bar)
+        part = withoutBox(part, { left: 0, top: bar.top, right: width, bottom: height });
+    if (navBar && !(0, inspect_1.inNavBarHeader)(navBar, actor.node.fiber))
+        part = withoutBox(part, { left: 0, top: 0, right: width, bottom: navBar.bottom });
+    for (let attempt = 0; attempt < MAX_COVER_CUTS; attempt++) {
+        if (part === null || part.right - part.left < MIN_VISIBLE_PT || part.bottom - part.top < MIN_VISIBLE_PT)
+            throw refusal;
+        const hit = await hitAt(Math.round((part.left + part.right) / 2), Math.round((part.top + part.bottom) / 2));
+        if (!hit || (0, inspect_1.isWithin)(hit, actor.node.fiber) || (0, inspect_1.isWithin)(actor.node.fiber, hit))
+            return;
+        // Something covers that point: cut its rect away and try what is left.
+        const cover = await (0, inspect_1.measureFiber)(hit);
+        if (!cover)
+            throw refusal;
+        part = withoutBox(part, { left: cover.x, top: cover.y, right: cover.x + cover.width, bottom: cover.y + cover.height });
+    }
+    throw refusal;
+}
+/** Switches native tabs the way the tab bar does: through the tab navigator that holds the tab. */
+function selectTab(snapshot, tab) {
+    for (const route of [...snapshot.routes].reverse()) {
+        const nav = route.navigation;
+        if (typeof nav.getState !== 'function' || typeof nav.navigate !== 'function')
+            continue;
+        let state;
+        try {
+            state = nav.getState();
+        }
+        catch {
+            continue;
+        }
+        if (!(0, types_1.isRecord)(state) || !Array.isArray(state.routes))
+            continue;
+        const target = state.routes.find((candidate) => (0, types_1.isRecord)(candidate) &&
+            typeof candidate.name === 'string' &&
+            (tab.screenKey !== null ? candidate.key === tab.screenKey : candidate.name === tab.title));
+        if ((0, types_1.isRecord)(target) && typeof target.name === 'string') {
+            callHandler('navigate', nav.navigate, [target.name]);
+            return;
+        }
+    }
+    throw new types_1.TaplineError('unsupported', `Can't switch to the "${tab.title}" tab from here; open its deep link with open_url instead.`);
+}
+/** A Modal's `onRequestClose`: on its host fiber, else on the components that render it (the `Modal` itself). */
+function requestCloseOf(host) {
+    // Up through the composites only: the first host above belongs to something else (maybe another Modal).
+    for (let fiber = host; fiber; fiber = fiber.return) {
+        if (fiber !== host && !(0, fiber_1.isCompositeTag)(fiber.tag))
+            break;
+        const props = (0, types_1.isRecord)(fiber.memoizedProps) ? fiber.memoizedProps : {};
+        if (typeof props.onRequestClose === 'function')
+            return props.onRequestClose;
+    }
+    return null;
+}
+/** `back`: what the back button or gesture does, on the focused screen; with a sheet open, closes the sheet. */
+async function back(rawParams) {
+    paramsOf(rawParams);
+    const snapshot = (0, inspect_1.takeSnapshot)();
+    const current = (0, inspect_1.currentRoute)(snapshot.routes);
+    // An open sheet is what back closes first (AGENT-TOOLS v1.4): the top Modal's own onRequestClose,
+    // which is what the system back gesture or a swipe down calls. One already on its way out is left alone.
+    const sheet = (0, inspect_1.openModalHosts)().filter((host) => !(0, inspect_1.closingModalHosts)().includes(host)).pop();
+    if (sheet) {
+        const onRequestClose = requestCloseOf(sheet);
+        // Most app sheets have no onRequestClose and close on a tap on the dimmed backdrop around them:
+        // a person taps that, so back does.
+        const backdrop = onRequestClose ? null : await backdropOf(snapshot);
+        if (backdrop) {
+            callHandler('onPress', backdrop.onPress, [pressEvent(backdrop.entry.node.fiber, backdrop.frame)]);
+            return { route: current?.chain ?? [], closed: 'sheet', ...(await settleOutcome()) };
+        }
+        if (!onRequestClose) {
+            // Named by what it shows, as `covered` names what is in front, so the agent finds its close control.
+            const shows = await frontLine(snapshot);
+            throw notActionable('no_action', `the open sheet${shows !== undefined ? ` (in front: ${shows})` : ''} has nothing for back to call (its Modal has no onRequestClose); tap its close control.`);
+        }
+        callHandler('onRequestClose', onRequestClose, []);
+        return { route: current?.chain ?? [], closed: 'sheet', ...(await settleOutcome()) };
+    }
+    if (!current) {
+        throw new types_1.TaplineError('unsupported', 'This app has no React Navigation screens Tapline can see, so there is no back.');
+    }
+    const nav = current.navigation;
+    let canGoBack = true;
+    try {
+        if (typeof nav.canGoBack === 'function')
+            canGoBack = nav.canGoBack();
+    }
+    catch {
+        canGoBack = true;
+    }
+    if (!canGoBack || typeof nav.goBack !== 'function') {
+        throw notActionable('no_action', `Nothing to go back to from ${current.chain.join(' › ')}.`);
+    }
+    callHandler('goBack', nav.goBack, []);
+    return { route: current.chain, ...(await settleOutcome()) };
+}
+/** How much of the screen, across and down, an element in front must cover to count as a sheet's backdrop. */
+const BACKDROP_SHARE = 0.9;
+/**
+ * The backdrop of the open sheet: an element in front that takes a tap, covers (nearly) the whole
+ * screen and shows nothing of its own (no text, no label), the dimmed area a person taps to close
+ * the sheet. A full-screen control with a text ("Tap to continue") is no backdrop. Null when there is none.
+ */
+async function backdropOf(snapshot) {
+    const { width, height } = snapshot.screen;
+    for (const entry of snapshot.entries) {
+        if (entry.tab || entry.info.disabled || entry.info.text.trim() !== '' || (entry.info.label ?? '') !== '')
+            continue;
+        const onPress = (0, inspect_1.findHandler)(entry.node, 'onPress');
+        if (!onPress)
+            continue;
+        const frame = await (0, inspect_1.measureFiber)(entry.node.fiber);
+        if (frame !== null && frame.width >= width * BACKDROP_SHARE && frame.height >= height * BACKDROP_SHARE) {
+            return { entry, frame, onPress };
+        }
+    }
+    return null;
+}
+/** Calls `name()` on the first instance that has it; whether one did. */
+function callInstanceMethod(instances, name) {
+    for (const instance of instances) {
+        if (!(0, types_1.isRecord)(instance) || typeof instance[name] !== 'function')
+            continue;
+        try {
+            instance[name].call(instance);
+            return true;
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return false;
+}
+/**
+ * What a finger does to a text input: focus it. React Native's TextInput puts `focus()` on its host
+ * instance (Paper: the fiber's stateNode; Fabric: `stateNode.canonical`), and `TextInput.State.focusTextInput`
+ * takes the same instance. Without either, the app's own onPressIn / onFocus handlers run.
+ */
+/** An input's instances, the host's and its components': the ones a `focus()` may be called on. */
+function inputInstances(entry) {
+    return [...(0, inspect_1.publicInstancesOf)(entry.node.fiber), ...entry.node.owners.map((owner) => owner.stateNode)];
+}
+function focusInput(entry, frame) {
+    const instances = inputInstances(entry);
+    if (callInstanceMethod(instances, 'focus'))
+        return;
+    try {
+        const state = react_native_1.TextInput.State;
+        if ((0, types_1.isRecord)(state) && typeof state.focusTextInput === 'function') {
+            const host = (0, inspect_1.publicInstancesOf)(entry.node.fiber).find(types_1.isRecord);
+            if (host) {
+                state.focusTextInput(host);
+                return;
+            }
+        }
+    }
+    catch {
+        // fall through to the handlers
+    }
+    for (const key of ['onPressIn', 'onFocus']) {
+        const handler = appHandler(entry, key);
+        if (handler)
+            callHandler(key, handler, [pressEvent(entry.node.fiber, frame)]);
+    }
+}
+async function pressLike(kind, rawParams) {
+    const params = paramsOf(rawParams);
+    const { snapshot, entry } = await resolveTarget(params.target, kind);
+    if (entry.tab) {
+        if (kind === 'longPress')
+            throw notActionable('no_action', `${describe(entry)} has no long-press action`);
+        selectTab(snapshot, entry.tab);
+        return { element: (0, inspect_1.toElement)(entry, null), ...keyboardNote(closeKeyboardFor(entry)), ...(await settleOutcome()) };
+    }
+    if (entry.navBack) {
+        const { route: _route, ...outcome } = await back({});
+        return { element: (0, inspect_1.toElement)(entry, null), ...outcome };
+    }
+    const actor = findActionable(snapshot, entry, kind, false);
+    const handlerName = kind === 'press' ? 'onPress' : 'onLongPress';
+    const actionName = kind === 'press' ? 'tap' : 'long-press';
+    if (!actor) {
+        if (entry.info.disabled)
+            throw notActionable('disabled', `${describe(entry)} is disabled; ${ENABLE_FIRST}.`);
+        throw notActionable('no_action', `${describe(entry)} has no ${actionName} action`);
+    }
+    if (actor.info.disabled || entry.info.disabled) {
+        throw notActionable('disabled', `${describe(actor)} is disabled; ${ENABLE_FIRST}.`);
+    }
+    // A finger on an input focuses it (AGENT-TOOLS v1.3): an input never answers no_action to a tap.
+    const focusing = kind === 'press' && actor.info.actions.includes('type');
+    const handler = focusing ? null : (0, inspect_1.findHandler)(actor.node, handlerName);
+    if (!handler && !focusing) {
+        throw notActionable('no_action', `${describe(actor)} has no ${actionName} action`);
+    }
+    const { element, frame } = await elementFor(actor);
+    const forced = await checkedOrForced(params.force === true, () => assertReachable(snapshot, actor, frame));
+    const closedKeyboard = closeKeyboardFor(actor);
+    if (handler)
+        callHandler(handlerName, handler, [pressEvent(actor.node.fiber, frame)]);
+    else {
+        // A finger focuses the input and also fires the input's own onPress (not an ancestor's: the
+        // input takes the touch).
+        focusInput(actor, frame);
+        const own = appHandler(actor, 'onPress');
+        if (own)
+            callHandler('onPress', own, [pressEvent(actor.node.fiber, frame)]);
+    }
+    return { element, ...keyboardNote(closedKeyboard), ...forced, ...(await settleOutcome()) };
+}
+function press(params) {
+    return pressLike('press', params);
+}
+function longPress(params) {
+    return pressLike('longPress', params);
+}
+/* -------------------------------------------------------------------------- */
+/* type                                                                        */
+/* -------------------------------------------------------------------------- */
+/** Props supplied by the app, i.e. everything except the host fiber's own (RN wraps handlers there). */
+function appHandler(entry, key) {
+    if (entry.node.owners.length === 0)
+        return (0, inspect_1.findHandler)(entry.node, key);
+    for (const owner of entry.node.owners) {
+        const props = (0, types_1.isRecord)(owner.memoizedProps) ? owner.memoizedProps : {};
+        const value = props[key];
+        if (typeof value === 'function')
+            return value;
+    }
+    return null;
+}
+function focusedInputInstance() {
+    try {
+        const state = react_native_1.TextInput.State;
+        if ((0, types_1.isRecord)(state) && typeof state.currentlyFocusedInput === 'function') {
+            return state.currentlyFocusedInput();
+        }
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+function ownsInstance(entry, instance) {
+    if (instance == null)
+        return false;
+    if ((0, inspect_1.publicInstancesOf)(entry.node.fiber).includes(instance))
+        return true;
+    return entry.node.owners.some((owner) => owner.stateNode === instance);
+}
+const defaultKeyboard = {
+    focusedInput: focusedInputInstance,
+    visible: () => (0, keyboard_1.keyboardState)()?.shown ?? true,
+    dismiss: () => {
+        try {
+            react_native_1.Keyboard.dismiss();
+        }
+        catch {
+            // nothing to close
+        }
+    },
+    blur: (input) => {
+        try {
+            const state = react_native_1.TextInput.State;
+            if ((0, types_1.isRecord)(state) && typeof state.blurTextInput === 'function') {
+                state.blurTextInput(input);
+                return;
+            }
+        }
+        catch {
+            // fall through to the instance's own blur
+        }
+        callInstanceMethod([input], 'blur');
+    },
+    top: () => (0, keyboard_1.keyboardState)()?.top ?? null,
+    // The instance's own focus() first: on Fabric only the public instance reaches the native field,
+    // and handing TextInputState the internal node moves the focus in JavaScript's books alone.
+    focus: (instances) => {
+        callInstanceMethod(instances, 'focus');
+    },
+};
+let keyboard = defaultKeyboard;
+/** Inject the keyboard and focus access (tests); pass null to restore the default. */
+function setKeyboardControl(next) {
+    keyboard = next ?? defaultKeyboard;
+}
+/**
+ * AGENT-TOOLS v1.4: with the keyboard up, an action on anything but the focused input closes it
+ * first, without submitting, as a person would. Call it after every refusal is decided. Returns
+ * whether it closed the keyboard (the result then says `closedKeyboard: true`).
+ */
+function closeKeyboardFor(actor) {
+    const focused = keyboard.focusedInput();
+    if (focused == null || !keyboard.visible())
+        return false;
+    if (!actor.tab && !actor.navBack && ownsInstance(actor, focused))
+        return false;
+    keyboard.dismiss();
+    // `Keyboard.dismiss()` blurs the focused input itself; when it didn't, do it.
+    if (keyboard.focusedInput() != null)
+        keyboard.blur(focused);
+    return true;
+}
+/**
+ * AGENT-TOOLS v1.6 §4: typing into another input that shows above the keyboard is what a person
+ * does to fill the next field of a form: the tap moves the focus there and the keyboard stays up.
+ * Moves the focus and returns true; false when the keyboard covers the input (even in part), when
+ * it isn't known where the keyboard is, or when the focus didn't move, and then the caller closes
+ * the keyboard the old way.
+ */
+/** How much of an input must show above the keyboard for a finger to reach it (AGENT-TOOLS v1.6 §4). */
+const SHOWS_ABOVE_KEYBOARD_PT = 10;
+async function moveFocusAboveKeyboard(entry) {
+    const focused = keyboard.focusedInput();
+    if (focused == null || !keyboard.visible() || ownsInstance(entry, focused))
+        return false;
+    const top = keyboard.top?.() ?? null;
+    if (top === null || keyboard.focus === undefined)
+        return false;
+    const frame = await (0, inspect_1.measureFiber)(entry.node.fiber);
+    if (frame === null || frame.y < 0 || Math.min(frame.y + frame.height, top) - frame.y < SHOWS_ABOVE_KEYBOARD_PT)
+        return false;
+    keyboard.focus(inputInstances(entry));
+    return ownsInstance(entry, keyboard.focusedInput());
+}
+/** `{ closedKeyboard: true }` for a result when the keyboard was closed, nothing otherwise. */
+function keyboardNote(closed) {
+    return closed ? { closedKeyboard: true } : {};
+}
+async function resolveInput(snapshot, rawTarget) {
+    if (rawTarget !== undefined && rawTarget !== null) {
+        const { snapshot: snap, entry } = await resolveTarget(rawTarget, 'type');
+        const input = findActionable(snap, entry, 'type', true);
+        if (!input)
+            throw notActionable('no_action', `${describe(entry)} is not an input`);
+        return { snapshot: snap, entry: input };
+    }
+    const snap = snapshot ?? (0, inspect_1.takeSnapshot)();
+    const inputs = snap.entries.filter((entry) => (0, inspect_1.isInputNode)(entry.node));
+    if (inputs.length === 0)
+        throw new types_1.TaplineError('not_found', 'No input on screen');
+    const focused = keyboard.focusedInput();
+    const focusedEntry = inputs.find((entry) => ownsInstance(entry, focused));
+    if (focusedEntry)
+        return { snapshot: snap, entry: focusedEntry };
+    const [only, ...rest] = inputs;
+    if (only && rest.length === 0)
+        return { snapshot: snap, entry: only };
+    const shown = inputs.slice(0, 5);
+    throw new types_1.TaplineError('ambiguous', `${inputs.length} inputs on screen; pass a target to pick one:`, shown.map((entry) => (0, inspect_1.refFor)(entry.node.fiber)), await candidateElements(shown));
+}
+function setNativeText(entry, text) {
+    for (const instance of (0, inspect_1.publicInstancesOf)(entry.node.fiber)) {
+        if ((0, types_1.isRecord)(instance) && typeof instance.setNativeProps === 'function') {
+            try {
+                instance.setNativeProps({ text });
+                return;
+            }
+            catch {
+                // try the next candidate
+            }
+        }
+    }
+}
+async function typeText(rawParams) {
+    const params = paramsOf(rawParams);
+    const submit = params.submit === true;
+    if (params.text !== undefined && typeof params.text !== 'string')
+        throw badParams('text must be a string');
+    const backspace = params.backspace;
+    if (backspace !== undefined && (typeof backspace !== 'number' || !Number.isInteger(backspace) || backspace < 0)) {
+        throw badParams('backspace must be a whole number of characters, 0 or more');
+    }
+    const deleting = typeof backspace === 'number' && backspace > 0;
+    if (params.text === undefined && !submit && !deleting)
+        throw badParams('text is required (or pass submit: true)');
+    // Deleting from the end edits what is there, so it never replaces the whole text.
+    const replace = params.replace !== false && !deleting;
+    const { snapshot, entry } = await resolveInput(null, params.target);
+    if (entry.info.disabled)
+        throw notActionable('disabled', `${describe(entry)} is not editable; ${ENABLE_FIRST}.`);
+    // Typing is a tap that focuses the input, then keys: a person couldn't do it where they couldn't tap,
+    // so the checks are a tap's, with the same reasons and the same `force`. The input that already has
+    // focus is the exception: the keyboard is up for it and a person types without touching it.
+    const forced = await checkedOrForced(params.force === true, async () => {
+        if (ownsInstance(entry, keyboard.focusedInput())) {
+            // An alert takes the keyboard away even from the focused input: a person answers it first.
+            assertNoBlockingAlert(entry);
+        }
+        else {
+            await assertReachable(snapshot, entry, await (0, inspect_1.measureFiber)(entry.node.fiber));
+        }
+    });
+    // Typing into the input that has focus leaves the keyboard alone. Another input above the keyboard
+    // takes the focus with the keyboard up; one the keyboard covers closes it first.
+    const closedKeyboard = !(await moveFocusAboveKeyboard(entry)) && closeKeyboardFor(entry);
+    const current = (0, inspect_1.currentInputValue)(entry.node);
+    // Characters, not UTF-16 units: an emoji is one.
+    const previous = deleting ? Array.from(current).slice(0, -backspace).join('') : current;
+    const typedText = typeof params.text === 'string' ? params.text : undefined;
+    const typed = typedText ?? (deleting ? '' : undefined);
+    const next = typed === undefined ? previous : replace ? typed : previous + typed;
+    const target = nativeTagOf(entry.node.fiber);
+    const controlled = typeof (0, inspect_1.findProp)(entry.node, 'value') === 'string';
+    if (typed !== undefined) {
+        const onChange = appHandler(entry, 'onChange');
+        const onChangeText = appHandler(entry, 'onChangeText');
+        if (!controlled) {
+            (0, inspect_1.rememberTyped)(entry.node, next);
+            setNativeText(entry, next);
+        }
+        if (onChange)
+            callHandler('onChange', onChange, [{ nativeEvent: { text: next, eventCount: 0, target } }]);
+        if (onChangeText)
+            callHandler('onChangeText', onChangeText, [next]);
+    }
+    if (submit) {
+        const event = { nativeEvent: { text: next, target } };
+        const onSubmit = appHandler(entry, 'onSubmitEditing');
+        const onEnd = appHandler(entry, 'onEndEditing');
+        if (onSubmit)
+            callHandler('onSubmitEditing', onSubmit, [event]);
+        if (onEnd)
+            callHandler('onEndEditing', onEnd, [event]);
+    }
+    const outcome = await settleOutcome();
+    const { element } = await elementFor(entry);
+    return { element: { ...element, value: (0, inspect_1.displayText)(next) }, value: (0, inspect_1.displayText)(next), ...keyboardNote(closedKeyboard), ...forced, ...outcome };
+}
+const rememberedOffsets = new WeakMap();
+/** Objects that may expose scroll methods: host public instances first, then list class instances. */
+function scrollCandidates(entry) {
+    const found = [];
+    for (const instance of (0, inspect_1.publicInstancesOf)(entry.node.fiber))
+        if ((0, types_1.isRecord)(instance))
+            found.push(instance);
+    for (const owner of entry.node.owners)
+        if ((0, types_1.isRecord)(owner.stateNode))
+            found.push(owner.stateNode);
+    // ScrollView exposes its responder, which can also scrollTo
+    for (const candidate of [...found]) {
+        if (typeof candidate.getScrollResponder === 'function') {
+            try {
+                const responder = candidate.getScrollResponder();
+                if ((0, types_1.isRecord)(responder))
+                    found.push(responder);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    return found;
+}
+function method(candidates, name) {
+    for (const candidate of candidates) {
+        const fn = candidate[name];
+        if (typeof fn === 'function')
+            return (arg) => fn.call(candidate, arg);
+    }
+    return null;
+}
+function readMetrics(candidates) {
+    for (const candidate of candidates) {
+        const metrics = candidate._scrollMetrics;
+        if ((0, types_1.isRecord)(metrics) && typeof metrics.offset === 'number') {
+            // Lengths of 0 mean "not laid out yet", i.e. unknown.
+            return {
+                offset: metrics.offset,
+                visibleLength: typeof metrics.visibleLength === 'number' && metrics.visibleLength > 0 ? metrics.visibleLength : null,
+                contentLength: typeof metrics.contentLength === 'number' && metrics.contentLength > 0 ? metrics.contentLength : null,
+            };
+        }
+    }
+    return null;
+}
+function rememberKey(entry, candidates) {
+    const state = entry.node.fiber.stateNode;
+    if (typeof state === 'object' && state !== null)
+        return state;
+    return candidates[0] ?? null;
+}
+const DIRECTIONS = ['down', 'up', 'left', 'right'];
+/** How far inside the clear area a scrolled-to element is placed, in points, when there is room (the same in Tapwright). */
+const TARGET_MARGIN = 8;
+/**
+ * How far content must move along one axis to bring [start, start + size] into [from, until], with
+ * the margin when it fits. Positive scrolls forward (down, right). 0 when it is clear already. An
+ * element longer than the area is lined up with its start.
+ */
+function axisShift(start, size, from, until) {
+    const room = until - from;
+    const margin = Math.min(TARGET_MARGIN, Math.max(0, (room - size) / 2));
+    if (start < from)
+        return start - (from + margin);
+    if (start + size > until)
+        return Math.min(start + size - (until - margin), start - (from + margin));
+    return 0;
+}
+/**
+ * `scroll` with `to: "target"` (AGENT-TOOLS v1.6): scrolls the scroll views that hold the element,
+ * innermost first, until it is on screen and clear of the bars iOS draws. One `scrollTo` each, from
+ * measured positions; a second round corrects for a list that laid out more rows on the way.
+ */
+async function scrollToTarget(params) {
+    const raw = params.target;
+    if (raw === undefined || raw === null)
+        throw badParams('to: "target" needs a target: the element to bring onto the screen');
+    if ((0, types_1.isRecord)(raw) && (raw.x !== undefined || raw.y !== undefined)) {
+        throw badParams('to: "target" needs an element (ref, id, label or text), not a point');
+    }
+    const { snapshot, entry: wanted } = await resolveTarget(raw);
+    const scrollers = [];
+    for (let p = wanted.node.parent; p >= 0;) {
+        const candidate = snapshot.entries[p];
+        if (candidate?.info.actions.includes('scroll'))
+            scrollers.push(candidate);
+        const node = snapshot.nodes[p];
+        if (!node)
+            break;
+        p = node.parent;
+    }
+    const { width, height } = snapshot.screen;
+    const navBar = (0, inspect_1.nativeNavBar)(snapshot);
+    const tabBar = (0, inspect_1.nativeTabBar)(snapshot);
+    const clearTop = navBar && !(0, inspect_1.inNavBarHeader)(navBar, wanted.node.fiber) ? navBar.bottom : 0;
+    const clearBottom = tabBar ? tabBar.top : height;
+    /**
+     * How far the element is from clear inside a scroll view, per axis. The area is the part of the
+     * scroll view that is on screen between the bars. A scroll view that is itself out of view (a
+     * list further down the page) has no such part: there the element only has to be inside the
+     * scroll view, and the outer one brings both onto the screen. Without a scroll view the area is
+     * the screen between the bars.
+     */
+    const shiftsIn = (frame, area) => {
+        let left = Math.max(area?.x ?? 0, 0);
+        let right = Math.min(area ? area.x + area.width : width, width);
+        let top = Math.max(area?.y ?? 0, clearTop);
+        let bottom = Math.min(area ? area.y + area.height : height, clearBottom);
+        if (area && (right - left < 1 || bottom - top < 1)) {
+            left = area.x;
+            right = area.x + area.width;
+            top = area.y;
+            bottom = area.y + area.height;
+        }
+        return { x: axisShift(frame.x, frame.width, left, right), y: axisShift(frame.y, frame.height, top, bottom) };
+    };
+    let settledMs = 0;
+    let settleCapMs;
+    let scrolled = null;
+    // A list drawn upside down (`inverted`) moves its content the other way: found out from the first move.
+    const inverted = new Set();
+    for (let round = 0; round < 3; round++) {
+        let movedThisRound = false;
+        for (const scroller of scrollers) {
+            const horizontal = (0, inspect_1.findProp)(scroller.node, 'horizontal') === true;
+            const [targetFrame, scrollFrame, state] = await Promise.all([
+                (0, inspect_1.measureFiber)(wanted.node.fiber),
+                (0, inspect_1.measureFiber)(scroller.node.fiber),
+                measureScrollState(scroller),
+            ]);
+            if (!targetFrame || !scrollFrame)
+                continue;
+            const shifts = shiftsIn(targetFrame, scrollFrame);
+            const wantedShift = horizontal ? shifts.x : shifts.y;
+            if (Math.abs(wantedShift) < 1)
+                continue;
+            const shift = inverted.has(scroller) ? -wantedShift : wantedShift;
+            const candidates = scrollCandidates(scroller);
+            const key = rememberKey(scroller, candidates);
+            const metrics = readMetrics(candidates);
+            const current = state?.offset ??
+                (metrics ? (horizontal ? { x: metrics.offset, y: 0 } : { x: 0, y: metrics.offset }) : ((key ? rememberedOffsets.get(key) : undefined) ?? { x: 0, y: 0 }));
+            // Never further back than the start. A scroll view resting at a negative offset (the system's
+            // inset under a large title) can't be asked to go back past where it rests.
+            let x = Math.max(Math.min(0, current.x), current.x + (horizontal ? shift : 0));
+            let y = Math.max(Math.min(0, current.y), current.y + (horizontal ? 0 : shift));
+            if (state) {
+                x = Math.min(x, Math.max(state.max.x, current.x));
+                y = Math.min(y, Math.max(state.max.y, current.y));
+            }
+            // At its start or end already: this scroll view can't bring the element any closer.
+            if (Math.abs(x - current.x) < 1 && Math.abs(y - current.y) < 1)
+                continue;
+            const scrollTo = method(candidates, 'scrollTo');
+            const scrollToOffset = method(candidates, 'scrollToOffset');
+            if (scrollTo)
+                scrollTo({ x, y, animated: false });
+            else if (scrollToOffset)
+                scrollToOffset({ offset: horizontal ? x : y, animated: false });
+            else
+                throw new types_1.TaplineError('unsupported', 'This scroll view exposes no scrollTo');
+            const outcome = await settleOutcome();
+            settledMs += outcome.settledMs;
+            if (outcome.settleCapMs !== undefined)
+                settleCapMs = outcome.settleCapMs;
+            const [after, movedFrame] = await Promise.all([measureScrollState(scroller), (0, inspect_1.measureFiber)(wanted.node.fiber)]);
+            const offset = after ? after.offset : { x, y };
+            if (key)
+                rememberedOffsets.set(key, offset);
+            // What the element did, measured: the scroll view may have held it back, or gone the other way.
+            // (When it can't be measured now, it is taken to have moved as asked.)
+            const asked = horizontal ? x - current.x : y - current.y;
+            const travelled = movedFrame ? (horizontal ? movedFrame.x - targetFrame.x : movedFrame.y - targetFrame.y) : -asked;
+            if (Math.abs(travelled) < 1)
+                continue;
+            if (travelled * asked > 0 && !inverted.has(scroller))
+                inverted.add(scroller);
+            // The answer names the innermost scroll view that moved.
+            if (scrolled === null || scrollers.indexOf(scroller) < scrollers.indexOf(scrolled.entry))
+                scrolled = { entry: scroller, offset };
+            else if (scrolled.entry === scroller)
+                scrolled.offset = offset;
+            movedThisRound = true;
+        }
+        if (!movedThisRound)
+            break;
+    }
+    const finalFrame = await (0, inspect_1.measureFiber)(wanted.node.fiber);
+    let reached = finalFrame !== null && (0, inspect_1.isOnScreen)(finalFrame, snapshot.screen);
+    if (finalFrame !== null && reached) {
+        // Clear inside every scroll view that holds it, and on the screen between the bars.
+        const areas = scrollers.length > 0 ? await Promise.all(scrollers.map((s) => (0, inspect_1.measureFiber)(s.node.fiber))) : [null];
+        for (const area of areas) {
+            const left = shiftsIn(finalFrame, area);
+            if (Math.abs(left.x) >= 1 || Math.abs(left.y) >= 1)
+                reached = false;
+        }
+        const onScreen = shiftsIn(finalFrame, null);
+        if (Math.abs(onScreen.x) >= 1 || Math.abs(onScreen.y) >= 1)
+            reached = false;
+    }
+    const target = (0, inspect_1.toElement)(wanted, finalFrame);
+    const settle = { settledMs, ...(settleCapMs !== undefined ? { settleCapMs } : {}) };
+    if (scrolled === null) {
+        if (reached)
+            return { element: target, target, offset: { x: 0, y: 0 }, moved: false, reached: true, unchanged: true, ...settle };
+        const first = scrollers[0];
+        if (!first)
+            throw notActionable('no_action', `${describe(wanted)} is not inside a scroll view`);
+        const state = await measureScrollState(first);
+        const { element } = await elementFor(first);
+        return { element, target, offset: state?.offset ?? { x: 0, y: 0 }, moved: false, reached: false, ...settle };
+    }
+    const { element } = await elementFor(scrolled.entry);
+    return { element, target, offset: scrolled.offset, moved: true, reached, ...settle };
+}
+async function scroll(rawParams) {
+    const params = paramsOf(rawParams);
+    const to = params.to;
+    if (to !== undefined && to !== 'start' && to !== 'end' && to !== 'target')
+        throw badParams('to must be "start", "end" or "target"');
+    if (to === 'target') {
+        if (params.direction !== undefined || params.amount !== undefined || params.fraction !== undefined) {
+            throw badParams('to: "target" takes no direction or amount');
+        }
+        return scrollToTarget(params);
+    }
+    const direction = params.direction === undefined ? 'down' : params.direction;
+    if (!DIRECTIONS.includes(direction))
+        throw badParams('direction must be down, up, left or right');
+    if (params.amount !== undefined && (typeof params.amount !== 'number' || !(params.amount > 0))) {
+        throw badParams('amount must be a positive number of points');
+    }
+    if (params.fraction !== undefined) {
+        if (params.amount !== undefined)
+            throw badParams('use fraction or amount, not both');
+        if (typeof params.fraction !== 'number' || !(params.fraction >= 0.1 && params.fraction <= 1)) {
+            throw badParams('fraction is a share of the scroll area, 0.1 to 1');
+        }
+    }
+    let entry;
+    let frame = null;
+    if (params.target !== undefined && params.target !== null) {
+        const resolved = await resolveTarget(params.target, 'scroll');
+        const scroller = findActionable(resolved.snapshot, resolved.entry, 'scroll', true);
+        if (!scroller)
+            throw notActionable('no_action', `${describe(resolved.entry)} is not inside a scroll view`);
+        entry = scroller;
+        frame = await (0, inspect_1.measureFiber)(entry.node.fiber);
+    }
+    else {
+        const snapshot = (0, inspect_1.takeSnapshot)();
+        const scrollers = snapshot.entries.filter((e) => e.info.actions.includes('scroll'));
+        const frames = await Promise.all(scrollers.map((e) => (0, inspect_1.measureFiber)(e.node.fiber)));
+        let best = null;
+        let bestFrame = null;
+        let bestArea = -1;
+        for (let i = 0; i < scrollers.length; i++) {
+            const candidate = scrollers[i];
+            if (!candidate)
+                continue;
+            const f = frames[i] ?? null;
+            if (f !== null && !(0, inspect_1.isOnScreen)(f, snapshot.screen))
+                continue;
+            const area = f ? f.width * f.height : 0;
+            if (area > bestArea) {
+                best = candidate;
+                bestFrame = f;
+                bestArea = area;
+            }
+        }
+        if (!best)
+            throw new types_1.TaplineError('not_found', 'No scroll view on screen');
+        entry = best;
+        frame = bestFrame;
+    }
+    const candidates = scrollCandidates(entry);
+    const key = rememberKey(entry, candidates);
+    const horizontal = (0, inspect_1.findProp)(entry.node, 'horizontal') === true;
+    const metrics = readMetrics(candidates);
+    const remembered = key ? rememberedOffsets.get(key) : undefined;
+    // The real position first: Tapline's own record is wrong after a person scrolls or the system clamps.
+    const measured = await measureScrollState(entry);
+    const known = measured !== null || metrics !== null || remembered !== undefined;
+    const current = measured
+        ? measured.offset
+        : metrics
+            ? horizontal
+                ? { x: metrics.offset, y: 0 }
+                : { x: 0, y: metrics.offset }
+            : (remembered ?? { x: 0, y: 0 });
+    const scrollTo = method(candidates, 'scrollTo');
+    const scrollToOffset = method(candidates, 'scrollToOffset');
+    const scrollToEnd = method(candidates, 'scrollToEnd');
+    let offset = { ...current };
+    if (to === 'start') {
+        offset = { x: 0, y: 0 };
+        if (scrollTo)
+            scrollTo({ x: 0, y: 0, animated: false });
+        else if (scrollToOffset)
+            scrollToOffset({ offset: 0, animated: false });
+        else
+            throw new types_1.TaplineError('unsupported', 'This scroll view exposes no scrollTo');
+    }
+    else if (to === 'end') {
+        if (!scrollToEnd)
+            throw new types_1.TaplineError('unsupported', 'This scroll view exposes no scrollToEnd');
+        scrollToEnd({ animated: false });
+        if (measured) {
+            offset = horizontal ? { x: measured.max.x, y: 0 } : { x: 0, y: measured.max.y };
+        }
+        else if (metrics && metrics.contentLength !== null && metrics.visibleLength !== null) {
+            const max = Math.max(0, metrics.contentLength - metrics.visibleLength);
+            offset = horizontal ? { x: max, y: 0 } : { x: 0, y: max };
+        }
+    }
+    else {
+        const visible = (measured ? (horizontal ? measured.visible.x : measured.visible.y) : null) ??
+            metrics?.visibleLength ??
+            (horizontal ? frame?.width : frame?.height) ??
+            (0, inspect_1.getScreen)().height;
+        const vertical = direction === 'down' || direction === 'up';
+        const areaSize = (vertical ? frame?.height : frame?.width) ?? visible;
+        const amount = typeof params.fraction === 'number'
+            ? Math.round(params.fraction * areaSize)
+            : typeof params.amount === 'number'
+                ? params.amount
+                : Math.round(visible * 0.8);
+        const dx = direction === 'right' ? amount : direction === 'left' ? -amount : 0;
+        const dy = direction === 'down' ? amount : direction === 'up' ? -amount : 0;
+        let x = Math.max(0, current.x + dx);
+        let y = Math.max(0, current.y + dy);
+        if (measured) {
+            // native clamps to [0, max]; the automatic inset (a negative resting offset) is out of reach
+            x = Math.min(x, measured.max.x);
+            y = Math.min(y, measured.max.y);
+        }
+        else if (metrics && metrics.contentLength !== null && metrics.visibleLength !== null) {
+            const max = Math.max(0, metrics.contentLength - metrics.visibleLength);
+            if (horizontal)
+                x = Math.min(x, max);
+            else
+                y = Math.min(y, max);
+        }
+        offset = { x, y };
+        if (scrollTo)
+            scrollTo({ x, y, animated: false });
+        else if (scrollToOffset)
+            scrollToOffset({ offset: horizontal ? x : y, animated: false });
+        else
+            throw new types_1.TaplineError('unsupported', 'This scroll view exposes no scrollTo');
+    }
+    const outcome = await settleOutcome();
+    // Report where the content really is, not where we asked it to go.
+    const after = await measureScrollState(entry);
+    if (after)
+        offset = after.offset;
+    const moved = !known && !after ? true : Math.abs(offset.x - current.x) >= 1 || Math.abs(offset.y - current.y) >= 1;
+    if (key)
+        rememberedOffsets.set(key, offset);
+    const { element } = await elementFor(entry, frame);
+    return { element, offset, moved, ...outcome };
+}
+/** The native type of a scroll view's content container (iOS and Android's horizontal one). */
+const SCROLL_CONTENT_HOSTS = new Set(['RCTScrollContentView', 'AndroidHorizontalScrollContentView']);
+const round2 = (value) => Math.round(value * 100) / 100;
+/**
+ * The scroll view's real offset, from where its content container sits inside it. On the new
+ * architecture `measureInWindow` includes the content offset, so scroll frame minus content frame
+ * is the offset. Null when either can't be measured (old architecture, nothing laid out).
+ */
+async function measureScrollState(entry) {
+    const scrollFiber = entry.node.fiber;
+    const horizontal = (0, inspect_1.findProp)(entry.node, 'horizontal') === true;
+    const children = (0, fiber_1.hostChildren)(scrollFiber);
+    // On iOS the RefreshControl is the scroll view's first child, so the first host child is not
+    // the content: pick the content container by its native type, else the largest child.
+    const typed = children.find((child) => typeof child.type === 'string' && SCROLL_CONTENT_HOSTS.has(child.type));
+    const scrollFrame = await (0, inspect_1.measureFiber)(scrollFiber);
+    if (!scrollFrame)
+        return null;
+    let contentFrame = typed ? await (0, inspect_1.measureFiber)(typed) : null;
+    if (!contentFrame && children.length > 1) {
+        const frames = await Promise.all(children.map((child) => (0, inspect_1.measureFiber)(child)));
+        let bestSize = -1;
+        for (const f of frames) {
+            if (!f)
+                continue;
+            const size = horizontal ? f.width : f.height;
+            if (size > bestSize) {
+                bestSize = size;
+                contentFrame = f;
+            }
+        }
+    }
+    if (!contentFrame) {
+        const first = (0, fiber_1.firstHostChild)(scrollFiber);
+        contentFrame = first ? await (0, inspect_1.measureFiber)(first) : null;
+    }
+    if (!contentFrame)
+        return null;
+    return {
+        offset: { x: round2(scrollFrame.x - contentFrame.x), y: round2(scrollFrame.y - contentFrame.y) },
+        max: {
+            x: Math.max(0, round2(contentFrame.width - scrollFrame.width)),
+            y: Math.max(0, round2(contentFrame.height - scrollFrame.height)),
+        },
+        visible: { x: scrollFrame.width, y: scrollFrame.height },
+    };
+}
+/* -------------------------------------------------------------------------- */
+/* toggle                                                                      */
+/* -------------------------------------------------------------------------- */
+async function toggle(rawParams) {
+    const params = paramsOf(rawParams);
+    if (params.value !== undefined && typeof params.value !== 'boolean')
+        throw badParams('value must be a boolean');
+    const { snapshot, entry } = await resolveTarget(params.target, 'toggle');
+    const control = findActionable(snapshot, entry, 'toggle', true);
+    if (!control)
+        throw notActionable('no_action', `${describe(entry)} is not a switch`);
+    if (control.info.disabled)
+        throw notActionable('disabled', `${describe(control)} is disabled; ${ENABLE_FIRST}.`);
+    const handler = (0, inspect_1.findHandler)(control.node, 'onValueChange');
+    if (!handler)
+        throw notActionable('no_action', `${describe(control)} is not a switch`);
+    const current = control.info.checked === true;
+    const next = typeof params.value === 'boolean' ? params.value : !current;
+    const forced = await checkedOrForced(params.force === true, async () => assertReachable(snapshot, control, await (0, inspect_1.measureFiber)(control.node.fiber)));
+    if (typeof params.value === 'boolean' && control.info.checked === params.value) {
+        // Already there: a person wouldn't touch it, so the handler isn't called and the keyboard stays.
+        const { element } = await elementFor(control);
+        return { element, value: params.value, unchanged: true, settledMs: 0 };
+    }
+    const closedKeyboard = closeKeyboardFor(control);
+    callHandler('onValueChange', handler, [next]);
+    const outcome = await settleOutcome();
+    const { element } = await elementFor(control);
+    return { element: { ...element, checked: next }, value: next, ...keyboardNote(closedKeyboard), ...forced, ...outcome };
+}
+/* -------------------------------------------------------------------------- */
+/* openURL / logs / reload / screenshot                                        */
+/* -------------------------------------------------------------------------- */
+const OPEN_URL_TIMEOUT_MS = 5000;
+async function openURL(rawParams) {
+    const params = paramsOf(rawParams);
+    if (typeof params.url !== 'string' || params.url === '')
+        throw badParams('url must be a non-empty string');
+    const url = params.url;
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new types_1.TaplineError('timeout', `Linking.openURL did not finish in ${OPEN_URL_TIMEOUT_MS} ms`)), OPEN_URL_TIMEOUT_MS);
+    });
+    try {
+        await Promise.race([react_native_1.Linking.openURL(url), timeout]);
+    }
+    catch (error) {
+        if (error instanceof types_1.TaplineError)
+            throw error;
+        throw new types_1.TaplineError('internal', `Linking.openURL failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+    return settleOutcome();
+}
+async function getLogs(rawParams) {
+    const params = paramsOf(rawParams);
+    if (params.since !== undefined && typeof params.since !== 'number')
+        throw badParams('since must be a number');
+    return { entries: (0, logs_1.getLogEntries)(typeof params.since === 'number' ? params.since : undefined) };
+}
+async function reload() {
+    if (typeof __DEV__ === 'undefined' || !__DEV__) {
+        throw new types_1.TaplineError('unsupported', 'reload is only available in development builds');
+    }
+    // Reply first: the reload tears the socket down.
+    setTimeout(() => {
+        try {
+            // An Expo app reloads through Expo (what `reloadAppAsync` from 'expo' calls): in Expo Go,
+            // DevSettings.reload() starts the bundle without Expo's native modules and it fails to load.
+            const expo = globalThis.expo;
+            const expoReload = (0, types_1.isRecord)(expo) ? expo.reloadAppAsync : undefined;
+            if (typeof expoReload === 'function') {
+                void Promise.resolve(expoReload.call(expo, 'Tapline: the agent asked for a reload')).catch(() => react_native_1.DevSettings.reload());
+                return;
+            }
+            react_native_1.DevSettings.reload();
+        }
+        catch {
+            // nothing to do
+        }
+    }, 100);
+    return {};
+}
+function loadViewShot() {
+    try {
+        const loaded = require('react-native-view-shot');
+        const candidate = (0, types_1.isRecord)(loaded) && (0, types_1.isRecord)(loaded.default) && loaded.default.captureScreen ? loaded.default : loaded;
+        if ((0, types_1.isRecord)(candidate) && typeof candidate.captureScreen === 'function') {
+            return candidate;
+        }
+    }
+    catch {
+        // not installed
+    }
+    return null;
+}
+function screenshotAvailable() {
+    return (react_native_1.Platform.OS === 'ios' && (0, native_1.nativeModule)() !== null) || loadViewShot() !== null;
+}
+async function screenshot(rawParams) {
+    const params = paramsOf(rawParams);
+    const format = params.format === 'png' ? 'png' : 'jpg';
+    const quality = typeof params.quality === 'number' && params.quality > 0 && params.quality <= 1 ? params.quality : 0.7;
+    const maxWidth = typeof params.maxWidth === 'number' && params.maxWidth > 0 ? Math.round(params.maxWidth) : 600;
+    // `fresh: false` (the live viewer's frames) draws what is on screen without making iOS render a
+    // new frame; only Tapline's native module can do that.
+    const fresh = params.fresh !== false;
+    const screen = (0, inspect_1.getScreen)();
+    const nativeWidth = Math.round(screen.width * screen.scale);
+    // The live viewer sizes frames by the screen's short side, so a turned phone keeps the preset's
+    // sharpness in px per point (in landscape the width is the long side); a screenshot keeps its width.
+    const shortSide = Math.min(screen.width, screen.height);
+    const target = params.fitShortSide === true && shortSide > 0 ? Math.round((maxWidth * screen.width) / shortSide) : maxWidth;
+    const width = Math.min(target, nativeWidth);
+    const height = Math.round((width * screen.height) / screen.width);
+    const native = react_native_1.Platform.OS === 'ios' && format === 'jpg' ? (0, native_1.nativeModule)() : null;
+    if (native !== null) {
+        try {
+            const data = await native.capture(width, quality, fresh);
+            if (data !== '')
+                return { mime: 'image/jpeg', data, width, height };
+        }
+        catch {
+            // fall back to view-shot below
+        }
+    }
+    const viewShot = loadViewShot();
+    if (!viewShot) {
+        throw new types_1.TaplineError('unsupported', 'Screenshots need react-native-view-shot in the app (npx expo install react-native-view-shot).');
+    }
+    // iOS renders view-shot's size at the screen scale (400 gives 1200 px on a 3x phone); Android takes pixels.
+    const perUnit = react_native_1.Platform.OS === 'ios' && screen.scale > 0 ? screen.scale : 1;
+    let data;
+    try {
+        data = await viewShot.captureScreen({ format, quality, result: 'base64', width: width / perUnit, height: height / perUnit });
+    }
+    catch (error) {
+        throw new types_1.TaplineError('internal', `captureScreen failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { mime: format === 'png' ? 'image/png' : 'image/jpeg', data, width, height };
+}
+/** A swipe's moves come about this often, as a finger's do on a 60 Hz screen. */
+const SWIPE_STEP_MS = 16;
+const SWIPE_DEFAULT_SECONDS = 0.35;
+const HOST_COMPONENT_TAG = 5;
+/** The host components from `fiber` up to the root, deepest first: where responder handlers live. */
+function hostChain(fiber) {
+    const chain = [];
+    for (let current = fiber; current; current = current.return) {
+        if (current.tag === HOST_COMPONENT_TAG)
+            chain.push(current);
+    }
+    return chain;
+}
+function callResponder(fiber, name, event) {
+    const props = (0, types_1.isRecord)(fiber.memoizedProps) ? fiber.memoizedProps : {};
+    const handler = props[name];
+    if (typeof handler !== 'function')
+        return undefined;
+    return handler(event);
+}
+/**
+ * React Native's negotiation for who handles a touch: the capture phase from the root down, then
+ * the bubble phase from the deepest view up; the first view whose handler answers true wins.
+ */
+function negotiate(chain, capture, bubble, event, skip) {
+    for (const fiber of [...chain].reverse()) {
+        if (fiber !== skip && callResponder(fiber, capture, event) === true)
+            return fiber;
+    }
+    for (const fiber of chain) {
+        if (fiber !== skip && callResponder(fiber, bubble, event) === true)
+            return fiber;
+    }
+    return undefined;
+}
+function touchEvent(history, x, y, at, target, active) {
+    const tag = nativeTagOf(target);
+    const touch = { identifier: 0, pageX: x, pageY: y, locationX: x, locationY: y, timestamp: at, target: tag };
+    return {
+        nativeEvent: { ...touch, touches: active ? [touch] : [], changedTouches: [touch] },
+        touchHistory: history,
+        target: tag,
+        currentTarget: tag,
+        timeStamp: at,
+        persist: () => undefined,
+        isPersistent: () => true,
+        preventDefault: () => undefined,
+        stopPropagation: () => undefined,
+        isDefaultPrevented: () => false,
+        isPropagationStopped: () => false,
+    };
+}
+function callProp(fiber, name) {
+    return (0, types_1.isRecord)(fiber.memoizedProps) ? fiber.memoizedProps[name] : undefined;
+}
+/** A Modal's own window, which takes any touch nobody inside it takes (so it doesn't fall through). */
+function isModalHost(fiber) {
+    return typeof fiber.type === 'string' && /ModalHostView/.test(fiber.type);
+}
+function isScrollHost(fiber) {
+    return typeof fiber.type === 'string' && /ScrollView|RCTScroll/.test(fiber.type);
+}
+/**
+ * `swipe`: a finger dragged from (x0, y0) to (x1, y1) over `seconds`, through React Native's own
+ * touch system: the views under the start point negotiate for it as they would for a finger
+ * (PanResponder, a sheet's swipe to close, a Pressable that gives way once the finger moves), and
+ * the winner gets the moves and the release with a real touch history. Gestures that
+ * react-native-gesture-handler or a native view handle (sliders, maps) don't go through it: they
+ * answer `no_action`, as does a start on a scroll view (`scroll` moves those).
+ */
+async function swipe(rawParams) {
+    const params = paramsOf(rawParams);
+    const numbers = [params.x0, params.y0, params.x1, params.y1];
+    if (!numbers.every((value) => typeof value === 'number' && Number.isFinite(value))) {
+        throw badParams('swipe needs x0, y0, x1 and y1 in points');
+    }
+    const [x0, y0, x1, y1] = numbers;
+    const seconds = typeof params.seconds === 'number' && params.seconds > 0 ? Math.min(params.seconds, 5) : SWIPE_DEFAULT_SECONDS;
+    const snapshot = (0, inspect_1.takeSnapshot)();
+    const screen = snapshot.screen;
+    if ([x0, x1].some((x) => x < 0 || x > screen.width) || [y0, y1].some((y) => y < 0 || y > screen.height)) {
+        throw badParams(`swipe points must be on the screen (0 to ${screen.width} across, 0 to ${screen.height} down)`);
+    }
+    assertNoBlockingAlert();
+    // What lies under the start point: the hit test, else the frontmost element whose frame holds it.
+    let start = await (0, inspect_1.hitTest)(x0, y0);
+    if (!start) {
+        const frames = await Promise.all(snapshot.entries.map((entry) => (0, inspect_1.measureFiber)(entry.node.fiber)));
+        snapshot.entries.forEach((entry, i) => {
+            const frame = frames[i];
+            if (frame && (0, inspect_1.frameContains)(frame, x0, y0))
+                start = entry.node.fiber;
+        });
+    }
+    if (!start)
+        throw notActionable('no_action', `Nothing at (${x0}, ${y0}) to swipe on.`);
+    const origin = start;
+    const chain = hostChain(origin);
+    const begin = Date.now();
+    const record = {
+        touchActive: true,
+        startPageX: x0,
+        startPageY: y0,
+        startTimeStamp: begin,
+        currentPageX: x0,
+        currentPageY: y0,
+        currentTimeStamp: begin,
+        previousPageX: x0,
+        previousPageY: y0,
+        previousTimeStamp: begin,
+    };
+    const history = { touchBank: [record], numberActiveTouches: 1, indexOfSingleActiveTouch: 0, mostRecentTimeStamp: begin };
+    const advance = (x, y, at) => {
+        record.previousPageX = record.currentPageX;
+        record.previousPageY = record.currentPageY;
+        record.previousTimeStamp = record.currentTimeStamp;
+        record.currentPageX = x;
+        record.currentPageY = y;
+        record.currentTimeStamp = at;
+        history.mostRecentTimeStamp = at;
+    };
+    // A native scroll view takes a drag along its axis on the native side, unless a view inside it claims
+    // the moves first (a swipeable row): then the swipe is the scroll view's, and `scroll` moves it.
+    const scrollHost = chain.find(isScrollHost);
+    const alongScroll = scrollHost !== undefined && (callProp(scrollHost, 'horizontal') === true ? Math.abs(x1 - x0) > Math.abs(y1 - y0) : Math.abs(y1 - y0) >= Math.abs(x1 - x0));
+    let claimedOnMove;
+    let responder = negotiate(chain, 'onStartShouldSetResponderCapture', 'onStartShouldSetResponder', touchEvent(history, x0, y0, begin, origin, true));
+    if (responder)
+        callResponder(responder, 'onResponderGrant', touchEvent(history, x0, y0, begin, origin, true));
+    const steps = Math.max(3, Math.min(120, Math.round((seconds * 1000) / SWIPE_STEP_MS)));
+    for (let i = 1; i <= steps; i += 1) {
+        await new Promise((resolve) => setTimeout(resolve, SWIPE_STEP_MS));
+        const x = x0 + ((x1 - x0) * i) / steps;
+        const y = y0 + ((y1 - y0) * i) / steps;
+        const at = Math.max(Date.now(), history.mostRecentTimeStamp + 1);
+        advance(x, y, at);
+        const event = touchEvent(history, x, y, at, origin, true);
+        // A view may take the touch over once the finger moves (a sheet's pan over a button inside it).
+        const taker = negotiate(responder ? hostChain(responder) : chain, 'onMoveShouldSetResponderCapture', 'onMoveShouldSetResponder', event, responder);
+        if (taker) {
+            const yields = responder === undefined || callResponder(responder, 'onResponderTerminationRequest', event) !== false;
+            if (yields) {
+                if (responder)
+                    callResponder(responder, 'onResponderTerminate', event);
+                responder = taker;
+                claimedOnMove = taker;
+                callResponder(responder, 'onResponderGrant', event);
+            }
+            else {
+                callResponder(taker, 'onResponderReject', event);
+            }
+        }
+        if (responder)
+            callResponder(responder, 'onResponderMove', event);
+    }
+    const end = Math.max(Date.now(), history.mostRecentTimeStamp + 1);
+    advance(x1, y1, end);
+    record.touchActive = false;
+    history.numberActiveTouches = 0;
+    const finalEvent = touchEvent(history, x1, y1, end, origin, false);
+    const scrollTakesIt = alongScroll && scrollHost !== undefined && !(claimedOnMove !== undefined && claimedOnMove !== scrollHost && (0, inspect_1.isWithin)(claimedOnMove, scrollHost));
+    if (!responder || isScrollHost(responder) || isModalHost(responder) || scrollTakesIt) {
+        if (responder)
+            callResponder(responder, 'onResponderTerminate', finalEvent);
+        const why = responder && isModalHost(responder) && !scrollTakesIt
+            ? "only the open sheet's own window took it, so nothing in the sheet handles a swipe (a sheet that closes by a swipe claims the touch when it starts)"
+            : responder || scrollTakesIt
+                ? 'it starts on a scroll view, which moves natively: use scroll'
+                : "nothing there takes a swipe through React Native's touch system";
+        throw notActionable('no_action', `Nothing took the swipe from (${x0}, ${y0}): ${why}. Gestures that react-native-gesture-handler or a native view handle (sliders, maps) can't be made from inside the app; Tapwright's swipe makes real ones.`);
+    }
+    callResponder(responder, 'onResponderRelease', finalEvent);
+    const owner = [...snapshot.entries].reverse().find((entry) => entry.info.interesting && (0, inspect_1.isWithin)(responder, entry.node.fiber));
+    const element = owner ? (await elementFor(owner)).element : null;
+    return { element, from: { x: x0, y: y0 }, to: { x: x1, y: y1 }, ...(await settleOutcome()) };
+}
+//# sourceMappingURL=actions.js.map