@avasapp/agent-bridge 0.5.0 → 0.6.0

package/dist/runtime/index.cjs

@@ -70,6 +70,95 @@ async function runUndos() {
   return { ran: batch.length, errors };
 }
 
+// src/runtime/tools/restore.ts
+var SUFFIX = ".restore";
+var SELF = "bridge.restore";
+var LAST = "scenario.restore";
+function pendingByArea(tools, detail = false) {
+  const out = {};
+  for (const [name, d] of Object.entries(tools)) {
+    if (!name.endsWith(SUFFIX) || name === SELF || typeof d === "function")
+      continue;
+    const area3 = name.slice(0, -SUFFIX.length);
+    try {
+      const found = d.pending?.({ detail });
+      if (found) out[area3] = found;
+    } catch (error) {
+      out[area3] = `pending check failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+  return out;
+}
+function journalByArea(tools) {
+  const out = {};
+  for (const [name, d] of restorers(tools)) {
+    try {
+      const data = d.journal?.();
+      if (data !== void 0) out[name] = data;
+    } catch {
+    }
+  }
+  return out;
+}
+function journalRev(tools) {
+  let rev = 0;
+  for (const [, d] of restorers(tools)) rev += d.journalRev?.() ?? 0;
+  return rev;
+}
+function restorers(tools) {
+  return Object.entries(tools).filter(([name, d]) => name.endsWith(SUFFIX) && name !== SELF && typeof d !== "function").map(([name, d]) => [name.slice(0, -SUFFIX.length), d]).filter((e) => typeof e[1] !== "function");
+}
+var INTERNAL_TOOLS = ["bridge.adopt"];
+function restoreTools(getTools) {
+  return {
+    "bridge.pending": {
+      maxArgs: 0,
+      description: "What bridge.restore would undo right now, per area (store, query, net, app, ...): the value is true, or detail such as a store's snapshot against its current value. Empty when nothing is pending. Changes nothing.",
+      run: () => pendingByArea(getTools(), true)
+    },
+    "bridge.adopt": {
+      maxArgs: 1,
+      description: "Internal: a session hands back its journal after a reload.",
+      run: async (data) => {
+        const tools = getTools();
+        const out = {};
+        if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error("bridge.adopt takes an object");
+        for (const [area3, part] of Object.entries(data)) {
+          const d = tools[`${area3}${SUFFIX}`];
+          if (typeof d === "function" || !d?.adopt) out[area3] = { adopted: [], already: [], changed: [], retry: part, error: "this area has no adopt" };
+          else
+            try {
+              out[area3] = await d.adopt(part);
+            } catch (error) {
+              out[area3] = { adopted: [], already: [], changed: [], retry: part, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        return out;
+      }
+    },
+    [SELF]: {
+      description: "Undo what the agent changed: runs every *.restore tool in name order, scenario.restore last, and returns each result or error.",
+      run: async () => {
+        const tools = getTools();
+        const results = {};
+        const names = Object.keys(tools).filter((name) => name.endsWith(SUFFIX) && name !== SELF).sort((a, b) => Number(a === LAST) - Number(b === LAST) || a.localeCompare(b));
+        for (const name of names) {
+          const definition = tools[name];
+          const run = typeof definition === "function" ? definition : definition.run;
+          try {
+            results[name] = await run();
+          } catch (error) {
+            results[name] = {
+              error: error instanceof Error ? error.message : String(error)
+            };
+          }
+        }
+        return results;
+      }
+    }
+  };
+}
+
 // src/runtime/tools/app.ts
 function selectReload(host, devSettingsReload) {
   return () => {
@@ -84,13 +173,14 @@ function selectReload(host, devSettingsReload) {
     }
   };
 }
-function appTools(reload) {
+function appTools(reload, getTools) {
   return {
     "app.reload": {
-      description: "Reload the app's JS (Expo's reloadAppAsync, else DevSettings.reload). Pending restores (store, query, mocks, pins) are lost. Returns before it reloads; a session waits for the new bridge and reports what was lost.",
+      description: "Reload the app's JS (Expo's reloadAppAsync, else DevSettings.reload). Pending restores (store, query, mocks, pins, storage) are lost, and the reply names them: restore first. Returns before it reloads; a session waits for the new bridge and reports what was lost.",
       run: () => {
         setTimeout(reload, 50);
-        return { reloading: true };
+        const lost = getTools ? Object.keys(pendingByArea(getTools())) : [];
+        return lost.length ? { reloading: true, lost: `pending restores are lost: ${lost.join(", ")}` } : { reloading: true };
       }
     },
     "app.restore": {
@@ -175,55 +265,6 @@ function logTools(logs) {
   };
 }
 
-// src/runtime/tools/restore.ts
-var SUFFIX = ".restore";
-var SELF = "bridge.restore";
-var LAST = "scenario.restore";
-function pendingByArea(tools, detail = false) {
-  const out = {};
-  for (const [name, d] of Object.entries(tools)) {
-    if (!name.endsWith(SUFFIX) || name === SELF || typeof d === "function")
-      continue;
-    const area3 = name.slice(0, -SUFFIX.length);
-    try {
-      const found = d.pending?.({ detail });
-      if (found) out[area3] = found;
-    } catch (error) {
-      out[area3] = `pending check failed: ${error instanceof Error ? error.message : String(error)}`;
-    }
-  }
-  return out;
-}
-function restoreTools(getTools) {
-  return {
-    "bridge.pending": {
-      maxArgs: 0,
-      description: "What bridge.restore would undo right now, per area (store, query, net, app, ...): the value is true, or detail such as a store's snapshot against its current value. Empty when nothing is pending. Changes nothing.",
-      run: () => pendingByArea(getTools(), true)
-    },
-    [SELF]: {
-      description: "Undo what the agent changed: runs every *.restore tool in name order, scenario.restore last, and returns each result or error.",
-      run: async () => {
-        const tools = getTools();
-        const results = {};
-        const names = Object.keys(tools).filter((name) => name.endsWith(SUFFIX) && name !== SELF).sort((a, b) => Number(a === LAST) - Number(b === LAST) || a.localeCompare(b));
-        for (const name of names) {
-          const definition = tools[name];
-          const run = typeof definition === "function" ? definition : definition.run;
-          try {
-            results[name] = await run();
-          } catch (error) {
-            results[name] = {
-              error: error instanceof Error ? error.message : String(error)
-            };
-          }
-        }
-        return results;
-      }
-    }
-  };
-}
-
 // src/runtime/options-schema.ts
 var import_json_schema = require("@cfworker/json-schema");
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -465,6 +506,9 @@ var MODAL_HOSTS = /* @__PURE__ */ new Set(["RCTModalHostView", "ModalHostView"])
 var OVERLAY_HOST = "RNSFullWindowOverlay";
 var SCREEN_STACK = "RNSScreenStack";
 var STACK_SCREENS = /* @__PURE__ */ new Set(["RNSScreen", "RNSModalScreen"]);
+var TABS_HOSTS = /* @__PURE__ */ new Set(["RNSTabsHostIOS", "RNSTabsHostAndroid"]);
+var OLD_TAB_SCREENS = /* @__PURE__ */ new Set(["RNSBottomTabsScreen", "RNSTabsScreen"]);
+var TAB_SCREENS = /* @__PURE__ */ new Set(["RNSTabsScreenIOS", "RNSTabsScreenAndroid"]);
 var SEE_THROUGH = /* @__PURE__ */ new Set(["transparentModal", "containedTransparentModal", "overFullScreen"]);
 var undimmedSheet = (p) => {
   const at = p.sheetLargestUndimmedDetentIndex;
@@ -500,6 +544,23 @@ function stackScreens(stack) {
     presented: screens.slice(1).filter(coversWindow)
   };
 }
+function unselectedTabs(tabs) {
+  const selected = propsOf(tabs)?.navStateRequest?.selectedScreenKey;
+  const out = [];
+  let matches = 0;
+  if (typeof selected !== "string") return out;
+  const todo = tabs.child ? [tabs.child] : [];
+  while (todo.length) {
+    const f = todo.pop();
+    if (f.sibling) todo.push(f.sibling);
+    if (f.tag === HOST_COMPONENT && TAB_SCREENS.has(f.type)) {
+      if (propsOf(f)?.screenKey === selected) matches++;
+      else out.push(f);
+    } else if (f.child) todo.push(f.child);
+  }
+  return matches === 1 ? out : [];
+}
+var hasDom = (recs) => recs.some((r) => !!r.host.stateNode && "getBoundingClientRect" in r.host.stateNode);
 function hostAbove(host) {
   let up = host.return;
   while (up && up.tag !== HOST_COMPONENT) up = up.return;
@@ -513,6 +574,12 @@ var inside = (modal, top) => {
 };
 var SWITCH_HOSTS = /* @__PURE__ */ new Set(["RCTSwitch", "AndroidSwitch"]);
 var isFn = (v) => typeof v === "function";
+function isSwitchFiber(fiber) {
+  const p = propsOf(fiber);
+  if ((p?.accessibilityRole ?? p?.role) === "switch") return true;
+  const own = firstHost(fiber);
+  return !!own && SWITCH_HOSTS.has(String(own.type));
+}
 var isInputProps = (p) => isFn(p.onChangeText) || isFn(p.onChange) && typeof p.value !== "boolean" && ("value" in p || "defaultValue" in p || "placeholder" in p);
 var labelOf = (p) => p.accessibilityLabel ?? p["aria-label"];
 function actionNamesOf(p) {
@@ -520,7 +587,37 @@ function actionNamesOf(p) {
   return p.accessibilityActions.map((a) => a?.name).filter((name) => typeof name === "string");
 }
 var activates = (rec) => !!rec.actions && !!rec.element.actions?.includes("activate");
-var interesting = (p) => isFn(p.onPress) || actionNamesOf(p) !== null || isFn(p.onValueChange) || isInputProps(p) || typeof p.testID === "string" || typeof labelOf(p) === "string" || webViewNameOf(p) !== void 0;
+var TEXT_HOSTS = /^RCT(Virtual)?Text$/;
+var changesValue = (p) => isFn(p.onValueChange) || isFn(p.onSlidingComplete) || Array.isArray(p.values) && isFn(p.onChange);
+var isControl = (p) => isFn(p.onPress) || changesValue(p) || activatesProps(p);
+var activatesProps = (p) => !!actionNamesOf(p)?.includes("activate");
+function wrapsControls(rec) {
+  const skip = /* @__PURE__ */ new Set();
+  const markChain = (from) => {
+    for (let f = from; f; f = f.child) {
+      skip.add(f);
+      if (f.tag === HOST_COMPONENT) break;
+    }
+  };
+  markChain(rec.fiber);
+  let controls = 0;
+  const stack = rec.fiber.child ? [rec.fiber.child] : [];
+  while (stack.length) {
+    const f = stack.pop();
+    if (f.sibling) stack.push(f.sibling);
+    if (f.child) stack.push(f.child);
+    const p = propsOf(f);
+    if (!p || skip.has(f)) continue;
+    if (isInputProps(p)) return true;
+    if (!isControl(p)) continue;
+    const own = firstHost(f);
+    if (isFn(p.onPress) && !isFn(p.onValueChange) && own && TEXT_HOSTS.test(String(own.type))) continue;
+    markChain(f);
+    if (++controls >= 2) return true;
+  }
+  return false;
+}
+var interesting = (p) => isFn(p.onPress) || actionNamesOf(p) !== null || changesValue(p) || isInputProps(p) || typeof p.testID === "string" || typeof labelOf(p) === "string" || webViewNameOf(p) !== void 0;
 var ICON_GLYPHS = /[\uE000-\uF8FF]/g;
 function firstHost(fiber) {
   if (fiber.tag === HOST_COMPONENT) return fiber;
@@ -537,6 +634,7 @@ function absorb(rec, fiber, p) {
   const e = rec.element;
   if (!rec.input && isInputProps(p)) rec.input = fiber;
   if (!rec.press && isFn(p.onPress)) rec.press = fiber;
+  if (!rec.change && changesValue(p)) rec.change = fiber;
   const actions = actionNamesOf(p);
   if (!rec.actions && actions) {
     rec.actions = fiber;
@@ -589,14 +687,14 @@ var within = (host, ancestor) => {
 };
 function visibleArea(base, host, bars, window) {
   let area3 = base;
-  const clip2 = (r) => {
+  const clip = (r) => {
     area3 = area3 && intersect(area3, r);
   };
   for (const bar of bars) {
     if (within(host, bar)) continue;
     const r = measureHost(bar);
     if (!usable(r) || r.width < window.width * 0.9) continue;
-    clip2(
+    clip(
       r.y + r.height / 2 > window.height / 2 ? { x: -1e9, y: -1e9, width: 2e9, height: 1e9 + r.y } : { x: -1e9, y: r.y + r.height, width: 2e9, height: 1e9 }
     );
   }
@@ -658,6 +756,7 @@ function collectScreen(roots, window) {
       host,
       press: null,
       input: null,
+      change: null,
       actions: null,
       hidden,
       scroller,
@@ -671,8 +770,14 @@ function collectScreen(roots, window) {
     order.push(rec);
     return rec;
   };
+  const wrapper = /* @__PURE__ */ new Map();
   const buttonOf = (rec) => {
-    for (let r = rec; r; r = r.parent) if (r.press || activates(r)) return r;
+    for (let r = rec; r; r = r.parent)
+      if (r.press || activates(r)) {
+        let wraps = wrapper.get(r);
+        if (wraps === void 0) wrapper.set(r, wraps = wrapsControls(r));
+        return wraps ? null : r;
+      }
     return null;
   };
   const textHost = (host) => {
@@ -707,6 +812,8 @@ function collectScreen(roots, window) {
         for (const s of screens.covered) covered.add(s);
         for (const s of screens.presented) presented.add(s);
       }
+      if (OLD_TAB_SCREENS.has(fiber.type) && p?.isFocused === false) hidden = true;
+      if (TABS_HOSTS.has(fiber.type)) for (const s of unselectedTabs(fiber)) covered.add(s);
       if (fiber.type === OVERLAY_HOST) overlay = true;
       if (p && !hidden && (p.accessibilityRole ?? p.role) === "tablist") bars.push(fiber);
       if (!hidden && (MODAL_HOSTS.has(fiber.type) || presented.has(fiber))) {
@@ -758,6 +865,7 @@ function collectScreen(roots, window) {
   const covers2 = (x) => !!top && !x.overlay && !inside(x.modal, top);
   for (const scrollable of scrollByHost.values())
     scrollable.hidden || (scrollable.hidden = covers2(scrollable));
+  let measured = false;
   for (const rec of order) {
     const e = rec.element;
     rec.hidden || (rec.hidden = covers2(rec));
@@ -766,11 +874,13 @@ function collectScreen(roots, window) {
     e.kind = e.webview !== void 0 ? "webview" : rec.input ? "input" : rec.press || activates(rec) ? "button" : rec.parts.length ? "text" : "view";
     if (e.kind === "input" && e.editable === void 0) e.editable = true;
     const rect = measureHost(rec.host);
+    if (rect) measured = true;
     e.rect = round(rect);
     const own = scrollByHost.get(rec.host) ?? scrollByHost.get(hostAbove(rec.host));
     if (own) rec.scroller = own;
     rec.onScreen = isOnScreen(rec, rect, window, bars);
   }
+  const unmeasured = order.length > 0 && !measured && !hasDom(order) && !globalThis.nativeFabricUIManager;
   const named = /* @__PURE__ */ new Set();
   const single = (rec) => {
     const name = rec.element.webview;
@@ -783,18 +893,22 @@ function collectScreen(roots, window) {
     found: order.filter(
       (rec) => (rec.element.kind !== "text" || rec.element.text !== void 0) && single(rec)
     ),
-    scrollables: [...scrollByHost.values()]
+    scrollables: [...scrollByHost.values()],
+    unmeasured
   };
 }
+var UNMEASURED_ERROR = "No Fabric UIManager found (React Native's old architecture, or a test renderer), so elements can't be measured. agent-bridge screen tools need the New Architecture.";
 var focused = (found) => found.filter((f) => !f.hidden);
 function pressFiberOf(found) {
-  if (found.press) return { fiber: found.press, via: "onPress" };
-  if (activates(found)) return { fiber: found.actions, via: "accessibilityAction" };
+  if (found.press) return { fiber: found.press, via: "onPress", ancestor: false };
+  if (activates(found))
+    return { fiber: found.actions, via: "accessibilityAction", ancestor: false };
   for (let f = found.fiber.return; f; f = f.return) {
     const p = propsOf(f);
     if (!p) continue;
-    if (isFn(p.onPress)) return { fiber: f, via: "onPress" };
-    if (actionNamesOf(p)?.includes("activate")) return { fiber: f, via: "accessibilityAction" };
+    if (isFn(p.onPress)) return { fiber: f, via: "onPress", ancestor: true };
+    if (actionNamesOf(p)?.includes("activate"))
+      return { fiber: f, via: "accessibilityAction", ancestor: true };
   }
   return null;
 }
@@ -860,15 +974,16 @@ function matchTarget(found, target) {
 }
 var isAt = (target) => typeof target === "object" && target.at !== void 0;
 var indexOf = (target) => typeof target === "object" ? target.index : void 0;
-var clip = (s) => s.length > 40 ? `${s.slice(0, 39)}\u2026` : s;
-function describe(e) {
+function describe(e, max = 40, wholeIds = false) {
+  const clip = (s) => s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+  const id = (s) => wholeIds ? s : clip(s);
   const stated = e.checked !== void 0 || e.selected !== void 0 || e.expanded !== void 0;
   const bits = [stated && e.role ? e.role : e.kind];
   if (e.webview !== void 0) bits.push(JSON.stringify(e.webview));
   if (e.testID) bits.push(`#${e.testID}`);
   if (e.text) bits.push(JSON.stringify(clip(e.text)));
-  if (e.label && e.label !== e.text) bits.push(`label=${JSON.stringify(clip(e.label))}`);
-  if (e.placeholder) bits.push(`placeholder=${JSON.stringify(clip(e.placeholder))}`);
+  if (e.label && e.label !== e.text) bits.push(`label=${JSON.stringify(id(e.label))}`);
+  if (e.placeholder) bits.push(`placeholder=${JSON.stringify(id(e.placeholder))}`);
   if (e.value !== void 0) bits.push(`value=${JSON.stringify(clip(e.value))}`);
   if (e.checked !== void 0) bits.push(e.checked === true ? "checked" : e.checked === false ? "unchecked" : "mixed");
   if (e.selected !== void 0) bits.push(e.selected ? "selected" : "unselected");
@@ -890,7 +1005,8 @@ function resolveTarget(found, target, prefer, options) {
     reachable.filter((f) => f.onScreen),
     target
   );
-  if (!matches.length && options?.offscreen) matches = matchTarget(reachable, target);
+  const hasIndex = (options?.index ?? indexOf(target)) !== void 0;
+  if (options?.offscreen && (!matches.length || hasIndex)) matches = matchTarget(reachable, target);
   if (!matches.length) {
     const hidden = matchTarget(found, target)[0];
     if (hidden?.hidden)
@@ -901,7 +1017,7 @@ function resolveTarget(found, target, prefer, options) {
       throw new Error(
         `${showTarget(target)} matches ${describe(hidden.element)}, which is not on screen. Pass {scroll:true} to scroll it into view, or use screen.scroll`
       );
-    const unrendered = options?.offscreen ? ". A list renders only the rows near its window: for a row it has not rendered yet, screen.scroll {toEnd:true} or {by: points} first" : "";
+    const unrendered = options?.offscreen ? "" : ". A list renders only the rows near its window: pass {scroll:true} to page it for a row it has not rendered yet";
     throw new Error(
       `Nothing on screen matches ${showTarget(target)}. On screen: ${onScreenSummary(found)}${unrendered}`
     );
@@ -918,10 +1034,10 @@ function resolveTarget(found, target, prefer, options) {
     return pick;
   }
   if (matches.length > 1) {
-    const list = matches.slice(0, 10).map((f, i) => `${i}: ${describe(f.element)}`).join("; ");
+    const list2 = matches.slice(0, 10).map((f, i) => `${i}: ${describe(f.element)}`).join("; ");
     const example = typeof target === "string" ? `${JSON.stringify(options?.afterText ? [target, "<text>", { index: 1 }] : [target, { index: 1 }])} (index as the last argument)` : `${JSON.stringify({ ...target, index: 1 })} (index inside the target)`;
     throw new Error(
-      `${showTarget(target)} matches ${matches.length} elements; pick one with an index, e.g. ${example}, or use a narrower target. ${list}`
+      `${showTarget(target)} matches ${matches.length} elements; pick one with an index, e.g. ${example}, or use a narrower target. ${list2}`
     );
   }
   return matches[0];
@@ -946,22 +1062,64 @@ var event = (nativeEvent, target) => ({
   persist: noop
 });
 var eventCount = 0;
-function fillInput(found, text, options = {}) {
-  const input = found.input;
-  if (!input) throw new Error(`${describe(found.element)} is not a text input`);
+var has = (v) => v !== void 0 && v !== null;
+var isUncontrolled = (found) => !!found.input && !has(propsOf(found.input)?.value) && !has(propsOf(found.host)?.value);
+function setNativeText(found, text) {
+  for (const fiber of [found.host, found.input]) {
+    const node = fiber?.stateNode;
+    for (const target of [node, node?.canonical?.publicInstance]) {
+      if (target && typeof target.setNativeProps === "function") {
+        target.setNativeProps({ text });
+        return true;
+      }
+    }
+  }
+  const dom = found.host.stateNode;
+  if (dom && typeof dom === "object" && "value" in dom) {
+    dom.value = text;
+    return true;
+  }
+  return false;
+}
+var keysOf = (text) => {
+  const Segmenter = Intl.Segmenter;
+  return Segmenter ? Array.from(new Segmenter(void 0, { granularity: "grapheme" }).segment(text), (x) => x.segment) : Array.from(text);
+};
+async function fillInput(found, text, options = {}) {
+  if (!found.input) throw new Error(`${describe(found.element)} is not a text input`);
   if (found.element.editable === false)
     throw new Error(`${describe(found.element)} is not editable`);
   const { maxLength } = found;
   const value = maxLength === void 0 ? text : text.slice(0, Math.max(0, maxLength));
+  const uncontrolled = isUncontrolled(found);
+  let native = uncontrolled ? false : null;
+  let current = found;
+  const change = (next) => {
+    const target2 = { value: next };
+    if (uncontrolled && setNativeText(current, next)) native = true;
+    const input2 = current.input;
+    handler(input2, "onChangeText")?.(next);
+    eventCount += 1;
+    handler(input2, "onChange")?.(event({ text: next, eventCount }, target2));
+  };
   const target = { value };
-  handler(input, "onFocus")?.(event({ text: value }, target));
-  handler(input, "onChangeText")?.(value);
-  eventCount += 1;
-  handler(input, "onChange")?.(event({ text: value, eventCount }, target));
-  if (options.submit)
-    handler(input, "onSubmitEditing")?.(event({ text: value }, target));
+  handler(found.input, "onFocus")?.(event({ text: value }, target));
+  if (options.type && value) {
+    const keys = keysOf(value);
+    let typed = "";
+    for (const key of keys) {
+      typed += key;
+      handler(current.input, "onKeyPress")?.(event({ key: key === "\n" ? "Enter" : key }));
+      change(typed);
+      if (options.between) await options.between();
+      if (options.again) current = options.again(current);
+    }
+  } else change(value);
+  const input = current.input;
+  if (options.submit) handler(input, "onSubmitEditing")?.(event({ text: value }, target));
+  handler(input, "onEndEditing")?.(event({ text: value }, target));
   handler(input, "onBlur")?.(event({ text: value }, target));
-  return value;
+  return { filled: value, native };
 }
 var center = (rect) => rect ? { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 } : { x: 0, y: 0 };
 var disabledProps = (fiber) => {
@@ -969,43 +1127,204 @@ var disabledProps = (fiber) => {
   const state = p?.accessibilityState;
   return p?.disabled === true || state?.disabled === true || p?.["aria-disabled"] === true;
 };
+function refuseDisabled(found, fiber, force) {
+  if (!force && (found.element.disabled || disabledProps(fiber)))
+    throw new Error(
+      `${describe(found.element)} is disabled; pass {"force":true} as the last argument to act on it anyway`
+    );
+}
 function pressTargetOf(found, action) {
   if (action === void 0) return pressFiberOf(found);
   const fiber = actionFiberOf(found, action);
-  return fiber && { fiber, via: "accessibilityAction" };
+  return fiber && { fiber, via: "accessibilityAction", ancestor: fiber !== found.actions };
+}
+var isFn2 = (v) => typeof v === "function";
+var isToggle = (found) => !found.press && !!found.change && isFn2(propsOf(found.change)?.onValueChange) && isSwitchFiber(found.change);
+var HOLD = ["onPress", "onPressIn", "onLongPress"];
+function longPressFiberOf(found) {
+  let handlesPress = false;
+  for (let f = found.fiber; f; f = f.child) {
+    const p = propsOf(f);
+    if (isFn2(p?.onLongPress)) return { fiber: f, ancestor: false };
+    if (p && HOLD.some((k) => isFn2(p[k]))) handlesPress = true;
+    if (f === found.host) break;
+  }
+  if (handlesPress) return null;
+  for (let f = found.fiber.return; f; f = f.return) {
+    const p = propsOf(f);
+    if (isFn2(p?.onLongPress)) return { fiber: f, ancestor: true };
+    if (p && HOLD.some((k) => isFn2(p[k]))) return null;
+  }
+  return null;
+}
+var TAP_GESTURES = /* @__PURE__ */ new Set(["TapGestureHandler", "LongPressGestureHandler"]);
+function isTapGesture(g) {
+  if (!g || typeof g !== "object") return false;
+  const x = g;
+  if (typeof x.handlerName === "string" && TAP_GESTURES.has(x.handlerName)) return true;
+  if (typeof x.type === "string" && TAP_GESTURES.has(x.type)) return true;
+  return Array.isArray(x.gestures) && x.gestures.some(isTapGesture);
+}
+function tapDetectorBetween(found, until) {
+  for (let f = found.fiber; f; f = f.child) {
+    if (isTapGesture(propsOf(f)?.gesture)) return true;
+    if (f === found.host) break;
+  }
+  for (let f = found.fiber.return; f && f !== until; f = f.return) {
+    const p = propsOf(f);
+    if (isTapGesture(p?.gesture)) return true;
+    if (!until && p && HOLD.some((k) => isFn2(p[k]))) break;
+  }
+  return false;
 }
+var GESTURE_NOTE = "it is inside a react-native-gesture-handler GestureDetector, whose callbacks run on the UI thread and cannot be fired from here, so use a real tap (agent-device)";
+var gestureNote = (found) => tapDetectorBetween(found, null) ? `; ${GESTURE_NOTE}` : "";
 function pressElement(found, options = {}) {
   const { action } = options;
+  if (options.long) return longPress(found, options);
+  if (action === void 0 && isToggle(found)) {
+    refuseDisabled(found, found.change, options.force);
+    const now2 = propsOf(found.change)?.value;
+    handler(found.change, "onValueChange")?.(now2 !== true);
+    return "onValueChange";
+  }
   const target = pressTargetOf(found, action);
   if (!target) {
     const names = found.element.actions ?? [];
-    const has = names.length ? `; it has ${names.map((a) => JSON.stringify(a)).join(", ")}` : "";
+    const has2 = names.length ? `; it has ${names.map((a) => JSON.stringify(a)).join(", ")}` : "";
     throw new Error(
-      action === void 0 ? `${describe(found.element)} has no onPress or "activate" accessibility action` : `${describe(found.element)} has no accessibility action ${JSON.stringify(action)}${has}`
+      action === void 0 ? `${describe(found.element)} has no onPress or "activate" accessibility action${gestureNote(found)}` : `${describe(found.element)} has no accessibility action ${JSON.stringify(action)}${has2}`
     );
   }
-  const { fiber, via } = target;
-  if (!options.force && (found.element.disabled || disabledProps(fiber)))
+  const { fiber, via, ancestor } = target;
+  if (ancestor && action === void 0 && tapDetectorBetween(found, fiber))
     throw new Error(
-      `${describe(found.element)} is disabled; pass {"force":true} as the last argument to press anyway`
+      `${describe(found.element)} has no onPress of its own, and ${GESTURE_NOTE}; pressing the ancestor that has one would do something else`
     );
+  const from = ancestor ? "ancestor:" : "";
+  refuseDisabled(found, fiber, options.force);
   if (via === "accessibilityAction") {
     const actionName = action ?? "activate";
     handler(fiber, "onAccessibilityAction")?.(event({ actionName }));
-    return `accessibilityAction:${actionName}`;
+    return `${from}accessibilityAction:${actionName}`;
   }
+  const e = () => pressEvent(found);
+  handler(fiber, "onPressIn")?.(e());
+  handler(fiber, "onPress")?.(e());
+  handler(fiber, "onPressOut")?.(e());
+  return ancestor ? "ancestor" : "onPress";
+}
+var pressEvent = (found) => {
   const { x, y } = center(found.element.rect);
-  const e = () => event({
+  return event({
     locationX: found.element.rect ? found.element.rect.width / 2 : 0,
     locationY: found.element.rect ? found.element.rect.height / 2 : 0,
     pageX: x,
     pageY: y,
     timestamp: Date.now()
   });
-  handler(fiber, "onPressIn")?.(e());
-  handler(fiber, "onPress")?.(e());
-  handler(fiber, "onPressOut")?.(e());
-  return "onPress";
+};
+function longPress(found, options) {
+  if (options.action !== void 0)
+    throw new Error("{long:true} and {action} cannot be combined: long presses call onLongPress, actions send an accessibility action");
+  const target = longPressFiberOf(found);
+  if (!target)
+    throw new Error(`${describe(found.element)} has no onLongPress${gestureNote(found)}`);
+  refuseDisabled(found, target.fiber, options.force);
+  handler(target.fiber, "onPressIn")?.(pressEvent(found));
+  handler(target.fiber, "onLongPress")?.(pressEvent(found));
+  handler(target.fiber, "onPressOut")?.(pressEvent(found));
+  return target.ancestor ? "ancestor:onLongPress" : "onLongPress";
+}
+function itemsOfChildren(children, out = []) {
+  if (Array.isArray(children)) for (const c of children) itemsOfChildren(c, out);
+  else if (children && typeof children === "object") {
+    const p = children.props;
+    if (p && has(p.value) && typeof p.label === "string") out.push({ value: p.value, label: p.label });
+    else if (p) itemsOfChildren(p.children, out);
+  }
+  return out;
+}
+function pickerItems(fiber) {
+  const items = itemsOfChildren(propsOf(fiber)?.children);
+  if (items.length) return items;
+  const stack = fiber.child ? [fiber.child] : [];
+  while (stack.length) {
+    const f = stack.pop();
+    if (f.sibling) stack.push(f.sibling);
+    if (f.child) stack.push(f.child);
+    const p = propsOf(f);
+    if (p && has(p.value) && typeof p.label === "string") items.push({ value: p.value, label: p.label });
+  }
+  return items;
+}
+function isSlider(fiber) {
+  const p = propsOf(fiber);
+  if (["onSlidingStart", "onSlidingComplete", "minimumValue", "maximumValue", "step"].some((k) => k in p))
+    return true;
+  const own = firstHost(fiber);
+  return !!own && /Slider/.test(String(own.type));
+}
+function valueOf(found) {
+  const p = found.change && propsOf(found.change);
+  if (!p) return void 0;
+  if (has(p.value)) return p.value;
+  if (has(p.selectedValue)) return p.selectedValue;
+  if (Array.isArray(p.values) && typeof p.selectedIndex === "number") return p.values[p.selectedIndex];
+  return void 0;
+}
+var list = (xs) => xs.map((x) => JSON.stringify(x)).join(", ");
+function setControlValue(found, value, options = {}) {
+  const fiber = found.change;
+  const what = describe(found.element);
+  if (!fiber)
+    throw new Error(`${what} has no onValueChange (a Switch, Slider, Picker or SegmentedControl has one)`);
+  refuseDisabled(found, fiber, options.force);
+  const p = propsOf(fiber);
+  const call = (name, ...args) => handler(fiber, name)?.(...args);
+  if (isSwitchFiber(fiber)) {
+    if (typeof value !== "boolean") throw new Error(`${what} is a switch: pass true or false; got ${JSON.stringify(value)}`);
+    return void call("onValueChange", value);
+  }
+  if (Array.isArray(p.values)) {
+    if (!p.values.includes(value))
+      throw new Error(`${what} takes one of ${list(p.values)}; got ${JSON.stringify(value)}`);
+    const selectedSegmentIndex = p.values.indexOf(value);
+    call("onChange", event({ value, selectedSegmentIndex }));
+    return void call("onValueChange", value);
+  }
+  const items = pickerItems(fiber);
+  if (items.length || "selectedValue" in p) {
+    const index = items.findIndex((i) => i.value === value);
+    if (!items.length) throw new Error(`${what} is a picker but no Picker.Item children could be read`);
+    if (index < 0)
+      throw new Error(`${what} takes one of ${list(items.map((i) => i.value))}; got ${JSON.stringify(value)}`);
+    return void call("onValueChange", value, index);
+  }
+  const current = valueOf(found);
+  if (isSlider(fiber) || typeof current === "number") {
+    if (typeof value !== "number" || !Number.isFinite(value))
+      throw new Error(`${what} takes a number; got ${JSON.stringify(value)}`);
+    const slider = isSlider(fiber);
+    const min = typeof p.minimumValue === "number" ? p.minimumValue : slider ? 0 : void 0;
+    const max = typeof p.maximumValue === "number" ? p.maximumValue : slider ? 1 : void 0;
+    if (min !== void 0 && value < min || max !== void 0 && value > max)
+      throw new Error(`${what} takes a number between ${min ?? "-\u221E"} and ${max ?? "\u221E"}; got ${value}`);
+    const step = p.step;
+    if (typeof step === "number" && step > 0) {
+      const n = (value - (min ?? 0)) / step;
+      if (Math.abs(n - Math.round(n)) > 1e-6) {
+        const lo = (min ?? 0) + Math.floor(n) * step;
+        throw new Error(`${what} moves in steps of ${step}; got ${value} (nearest: ${lo}, ${lo + step})`);
+      }
+    }
+    call("onSlidingStart", value);
+    call("onValueChange", value);
+    return void call("onSlidingComplete", value);
+  }
+  if (typeof current === "string" && typeof value !== "string")
+    throw new Error(`${what} takes a string; got ${JSON.stringify(value)}`);
+  call("onValueChange", value);
 }
 
 // src/runtime/screen/find-text.ts
@@ -1237,6 +1556,63 @@ function mainScrollable(scrollables, window, need) {
     );
   return best.s;
 }
+var isVirtualized = (s) => s.fibers.some((f) => typeof propsOf(f)?.renderItem === "function");
+function pagingList(scrollables, window) {
+  const all = scrollables.filter((s) => !s.hidden && scrollEnabled(s) && isVirtualized(s)).map((s) => ({ s, rect: measureHost(s.host) })).filter(({ rect }) => onWindow(rect, window)).sort((a, b) => area2(b.rect) - area2(a.rect)).map(({ s }) => s);
+  const list2 = all.find((s) => !isHorizontal(s)) ?? all[0] ?? null;
+  return { list: list2, skipped: all.filter((s) => s !== list2) };
+}
+async function awaitRows(read, has2, maxMs = 250) {
+  const sig = () => {
+    const { metrics, rows } = read();
+    return { metrics, rows, key: `${rows}|${metrics?.max}|${metrics?.offset}` };
+  };
+  let cur = sig();
+  let still = 0;
+  for (let waited = 0; waited < maxMs; waited += 16) {
+    if (has2()) break;
+    await wait(16);
+    const next = sig();
+    still = next.key === cur.key ? still + 1 : 0;
+    cur = next;
+    if (cur.rows > 0 && still >= 4) break;
+  }
+  return cur.metrics;
+}
+
+// src/runtime/screen/snapshot-text.ts
+var ELEMENT_KINDS = ["button", "input", "text", "view", "webview"];
+var center2 = (r) => ({ x: r.x + r.width / 2, y: r.y + r.height / 2 });
+function underScope(found, scope) {
+  for (let f = found.fiber; f; f = f.return) if (f === scope.fiber) return true;
+  return false;
+}
+function snapshotText(lines, hidden, empty = "(nothing on screen)") {
+  const base = lines.map(({ element: e }) => {
+    const bits = [describe(e, 80, true)];
+    if (e.editable === false) bits.push("readonly");
+    if (e.actions?.length) bits.push(`actions=${e.actions.join(",")}`);
+    if (e.onScreen === false) bits.push("offscreen");
+    if (e.hidden) bits.push("hidden");
+    return bits.join(" ");
+  });
+  const seen = /* @__PURE__ */ new Map();
+  for (const l of base) seen.set(l, (seen.get(l) ?? 0) + 1);
+  const out = base.map((l, i) => {
+    const { element: e, index } = lines[i];
+    const repeats = (seen.get(l) ?? 0) > 1;
+    const named = !!(e.testID || e.text || e.label || e.placeholder);
+    const bits = [l];
+    if (repeats && index !== void 0) bits.push(`index=${index}`);
+    if (e.rect && (repeats && index === void 0 || !named)) {
+      const c = center2(e.rect);
+      bits.push(`@${Math.round(c.x)},${Math.round(c.y)}`);
+    }
+    return bits.join(" ");
+  });
+  if (hidden) out.push(`(${hidden} hidden: on screens not in front; {all:true} lists them)`);
+  return lines.length || hidden ? out.join("\n") : empty;
+}
 
 // src/runtime/screen/settle.ts
 var STATE = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/commits");
@@ -1309,6 +1685,7 @@ async function settle(options = {}) {
 
 // src/runtime/screen/wait-for.ts
 var POLL_MS = 50;
+var NO_PAGING = "waitFor does not page lists for rows they have not rendered; wait for the list, then use press, fill or setValue with {scroll:true}";
 function nearMissNote(found, target) {
   const text = typeof target === "string" ? target : target.text;
   const near = text ? nearMisses(found, text) : [];
@@ -1359,7 +1736,7 @@ function waitForTarget(collect, target, options = {}, reveal) {
           const what = options.gone ? "to disappear" : "to appear";
           reject(
             new Error(
-              `Timed out after ${timeoutMs} ms waiting for ${showTarget(target)} ${what}. On screen: ${onScreenSummary(found)}${nearMissNote(found, target)}`
+              `Timed out after ${timeoutMs} ms waiting for ${showTarget(target)} ${what}. On screen: ${onScreenSummary(found)}${nearMissNote(found, target)}${options.scroll && !options.gone ? `. ${NO_PAGING}` : ""}`
             )
           );
         }
@@ -1379,8 +1756,25 @@ function waitForTarget(collect, target, options = {}, reveal) {
 }
 
 // src/runtime/screen/index.ts
+function snapshotKinds(kinds) {
+  if (kinds === void 0) return [];
+  const list2 = typeof kinds === "string" ? [kinds] : kinds;
+  if (!Array.isArray(list2))
+    throw new Error(`screen.snapshot kinds is a list like ["button","input"], not ${JSON.stringify(kinds)}`);
+  for (const k of list2)
+    if (!ELEMENT_KINDS.includes(k))
+      throw new Error(
+        `screen.snapshot kinds are ${ELEMENT_KINDS.join(", ")}; ${JSON.stringify(k)} is not one (a line that starts with switch, checkbox, tab or another role is a button: ask for "button")`
+      );
+  return list2;
+}
 function createScreen(env) {
-  const collectAll = () => collectScreen(env.roots(), env.window());
+  const collectLoose = () => collectScreen(env.roots(), env.window());
+  const collectAll = () => {
+    const all = collectLoose();
+    if (all.unmeasured) throw new Error(UNMEASURED_ERROR);
+    return all;
+  };
   const collect = () => collectAll().found;
   const collectSettled = async () => {
     let prev = null;
@@ -1435,39 +1829,258 @@ function createScreen(env) {
       );
     return shown;
   };
+  const PAGE_LIMIT = 40;
+  const PAGE_MS = 1e4;
+  const pagingBudget = (scroll) => {
+    if (scroll === null || typeof scroll !== "object") return PAGE_MS;
+    const bad = Object.keys(scroll).filter((k) => k !== "timeoutMs");
+    if (bad.length)
+      throw new Error(`Unknown scroll option ${bad.map((k) => JSON.stringify(k)).join(", ")}. Valid: timeoutMs`);
+    const ms = scroll.timeoutMs;
+    if (ms === void 0) return PAGE_MS;
+    if (typeof ms !== "number" || !Number.isFinite(ms) || ms <= 0)
+      throw new Error(`scroll.timeoutMs is a positive number of milliseconds; got ${JSON.stringify(ms)}`);
+    return ms;
+  };
+  const scrollableAgain = (host) => {
+    const node = host.stateNode;
+    return collectAll().scrollables.find(
+      (s) => s.host === host || node != null && s.host.stateNode === node
+    );
+  };
+  const rendered = (target, index) => () => matchTarget(collect().filter((f) => !f.hidden), target).length > (indexOf(target) ?? index ?? 0);
+  const nameOf = (host) => {
+    const el = collectAll().found.find((f) => f.host === host || f.host.stateNode === host.stateNode);
+    return el ? describe(el.element) : "the list";
+  };
+  const pageList = async (first, skipped, has2, budgetMs) => {
+    const { host } = first;
+    const name = nameOf(host);
+    const first0 = metricsOf(first);
+    if (!first0) return { found: false, note: `${name} has no readable scroll position` };
+    const start = first0;
+    const size = Math.max(1, ((isHorizontal(first) ? start.view?.width : start.view?.height) ?? 400) * 0.9);
+    const deadline = performance.now() + budgetMs;
+    let pages = 0;
+    let lowest = start.offset;
+    let highest = start.offset;
+    let max = start.max;
+    let stop = "both ends";
+    const horizontal = isHorizontal(first);
+    const node = host.stateNode;
+    let span = null;
+    const readRows = () => {
+      const now2 = scrollableAgain(host);
+      const metrics = now2 ? metricsOf(now2) : null;
+      let rows = 0;
+      let top = Infinity;
+      let bottom = -Infinity;
+      for (const f of collectAll().found) {
+        let inList = false;
+        for (let x = f.scroller; x; x = x.parent)
+          if (x.host === host || node != null && x.host.stateNode === node) inList = true;
+        if (!inList) continue;
+        if (f.onScreen) rows++;
+        const box = metrics?.view && !metrics.inverted ? measureHost(f.host) : null;
+        if (!metrics?.view || !box) continue;
+        const at = (horizontal ? box.x - metrics.view.x : box.y - metrics.view.y) + metrics.offset;
+        top = Math.min(top, at);
+        bottom = Math.max(bottom, at + (horizontal ? box.width : box.height));
+      }
+      span = top <= bottom ? { top, bottom } : null;
+      return { metrics, rows };
+    };
+    const go = async (offset) => {
+      const now2 = scrollableAgain(host);
+      if (!now2) return false;
+      const before = metricsOf(now2);
+      scrollToOffset(now2, offset);
+      await awaitScroll(now2, before?.offset, offset);
+      pages++;
+      if (has2()) return true;
+      const m = await awaitRows(readRows, has2);
+      if (m) {
+        lowest = Math.min(lowest, m.offset);
+        highest = Math.max(highest, m.offset);
+        max = m.max;
+      }
+      return has2();
+    };
+    const sweep = async (dir, until, limit) => {
+      const from = pages;
+      while (true) {
+        if (pages - from >= limit || performance.now() >= until) {
+          stop = pages >= PAGE_LIMIT ? `the ${PAGE_LIMIT}-page limit` : `the ${budgetMs} ms budget`;
+          return false;
+        }
+        const m = readRows().metrics;
+        if (!m) return false;
+        const viewSize = size / 0.9;
+        const reach = span;
+        const want = dir === 1 ? Math.max(m.offset + size, reach ? reach.bottom : -Infinity) : Math.min(m.offset - size, reach ? reach.top - viewSize : Infinity);
+        const next = dir === 1 ? Math.min(m.max ?? Infinity, want) : Math.max(0, want);
+        if (Math.abs(next - m.offset) < 1) {
+          const grown = await awaitRows(readRows, has2, 400);
+          if (has2()) return true;
+          if (dir === 1 && grown && (grown.max ?? 0) - m.offset >= 1) continue;
+          return false;
+        }
+        if (await go(next)) return true;
+      }
+    };
+    let found = false;
+    try {
+      const downFirst = start.max == null || start.max - start.offset <= start.offset;
+      const order = downFirst ? [1, -1] : [-1, 1];
+      const now2 = performance.now();
+      for (const [i, dir] of order.entries()) {
+        const otherRoom = dir === -1 ? start.max == null || start.max - start.offset >= 1 : start.offset >= 1;
+        const half = i === 0 && otherRoom;
+        const share = half ? now2 + budgetMs / 2 : deadline;
+        const limit = half ? PAGE_LIMIT / 2 : PAGE_LIMIT - pages;
+        if (dir === -1 && start.offset < 1) continue;
+        if (i === 1 && pages) await go(start.offset);
+        if (await sweep(dir, share, limit)) return found = true, done();
+      }
+    } finally {
+      if (!found) {
+        const now2 = scrollableAgain(host);
+        if (now2) {
+          await scrolled(now2, () => (scrollToOffset(now2, start.offset), start.offset));
+          await settle();
+        }
+      }
+    }
+    return done();
+    function done() {
+      const where = `up to offset ${Math.round(lowest)} and down to offset ${Math.round(highest)} of ${max == null ? "?" : Math.round(max)}`;
+      const left = skipped.length ? `. Not paged: ${skipped.map((s) => nameOf(s.host)).join(", ")}` : "";
+      return {
+        found,
+        note: found ? "" : `{scroll:true} paged ${name} ${pages} page(s), ${where}, without rendering a match, then scrolled back to offset ${Math.round(start.offset)}. Stopped at: ${stop}${left}`
+      };
+    }
+  };
+  const pageFor = async (has2, budgetMs) => {
+    const { list: list2, skipped } = pagingList(collectAll().scrollables, env.window());
+    if (!list2)
+      return { found: false, note: "{scroll:true} found no FlatList, SectionList or FlashList on screen to page" };
+    return pageList(list2, skipped, has2, budgetMs);
+  };
   const resolve = async (target, prefer, options) => {
-    const found = resolveTarget(collect(), target, prefer, {
-      ...options,
-      offscreen: options.scroll
-    });
-    return found.onScreen ? found : reveal(found);
+    const pick = () => resolveTarget(collect(), target, prefer, { ...options, offscreen: !!options.scroll });
+    let note = "";
+    if (options.scroll && typeof target === "object" && target.at !== void 0)
+      throw new Error(
+        "{at:[x,y]} is a point on the screen and can't be scrolled to; drop {scroll:true} or target by text or testID"
+      );
+    const has2 = rendered(target, options.index);
+    if (options.scroll && !has2()) {
+      const paged = await pageFor(has2, pagingBudget(options.scroll));
+      note = paged.note;
+      if (!paged.found) {
+        try {
+          return await settleOn(pick());
+        } catch (error) {
+          throw note ? new Error(`${error.message}. ${note}`) : error;
+        }
+      }
+    }
+    return settleOn(pick());
+  };
+  const settleOn = async (found) => found.onScreen ? found : reveal(found);
+  const build = (options) => {
+    const { all, format, within: within2 } = options;
+    if (format !== void 0 && format !== "json" && format !== "text")
+      throw new Error(`screen.snapshot format is "json" or "text", not ${JSON.stringify(format)}`);
+    const kinds = snapshotKinds(options.kinds);
+    const found = all ? collectLoose().found : collect();
+    let pool;
+    let hidden;
+    if (all) {
+      pool = found;
+    } else {
+      const shown = focused(found);
+      pool = shown.filter((f) => f.onScreen);
+      hidden = found.length - shown.length || void 0;
+    }
+    let items = pool.map((f) => ({
+      found: f,
+      element: all ? { ...f.element, onScreen: f.onScreen, ...f.hidden && { hidden: true } } : f.element
+    }));
+    let scoped = "";
+    if (within2 !== void 0) {
+      const scope = scopeOf(found, within2, !!all);
+      if (!scope.element.rect)
+        throw new Error(`${describe(scope.element)} has no position, so it can't scope a snapshot`);
+      scoped = describe(scope.element);
+      items = items.filter((i) => i.found !== scope && underScope(i.found, scope));
+    }
+    if (kinds.length) items = items.filter((i) => kinds.includes(i.element.kind));
+    const empty = kinds.length || scoped ? `(no ${kinds.length ? kinds.join("/") : ""} elements${scoped ? ` inside ${scoped}` : ""})`.replace("(no  ", "(no ") : void 0;
+    return {
+      hidden,
+      empty,
+      items: items.map((i) => ({ element: i.element, index: matchIndex(pool, i.found) }))
+    };
+  };
+  const matchIndex = (pool, f) => {
+    const e = f.element;
+    const name = e.testID ?? e.label ?? e.placeholder ?? e.text;
+    if (!name) return void 0;
+    const at = matchTarget(pool, name).indexOf(f);
+    return at < 0 ? void 0 : at;
+  };
+  const scopeOf = (found, within2, all) => {
+    const ranged = indexOf(within2) !== void 0;
+    if (!ranged) {
+      const matches = matchTarget(found.filter((f) => !f.hidden && (all || f.onScreen)), within2);
+      if (matches.length > 1) {
+        const first = matches[0].element;
+        const fix = typeof within2 === "string" ? {
+          [first.testID === within2 ? "testID" : first.label === within2 ? "label" : first.placeholder === within2 ? "placeholder" : "text"]: within2,
+          index: 1
+        } : { ...within2, index: 1 };
+        throw new Error(
+          `within ${showTarget(within2)} matches ${matches.length} elements; pick one with ${JSON.stringify({ within: fix })}`
+        );
+      }
+    }
+    return resolveTarget(found, within2, void 0, { offscreen: all });
   };
   return {
     snapshot(options = {}) {
-      const found = collect();
-      if (options.all)
-        return {
-          elements: found.map((f) => ({
-            ...f.element,
-            onScreen: f.onScreen,
-            ...f.hidden && { hidden: true }
-          }))
-        };
-      const shown = focused(found);
-      const elements = shown.filter((f) => f.onScreen).map((f) => f.element);
-      const hidden = found.length - shown.length;
+      const { items, hidden } = build(options);
+      const elements = items.map((i) => i.element);
       return hidden ? { elements, hidden } : { elements };
     },
-    findText: (text, options) => findText(collect(), text, options),
+    /** `snapshot` as one line per element. */
+    snapshotText(options = {}) {
+      const { items, hidden, empty } = build(options);
+      return snapshotText(items, hidden, empty);
+    },
+    findText: (text, options) => findText(collectLoose().found, text, options),
     async fill(target, text, options = {}) {
       const found = await resolve(target, (f) => !!f.input, {
         index: options.index,
         afterText: true,
         scroll: options.scroll
       });
-      const filled = fillInput(found, String(text), options);
+      const { filled, native } = await fillInput(found, String(text), {
+        ...options,
+        between: async () => void await settle(),
+        again: reread
+      });
       await settle();
-      return { filled, element: reread(found).element };
+      const element = reread(found).element;
+      if (native === true) return { filled, element: { ...element, value: filled } };
+      if (native === false)
+        return {
+          filled,
+          element,
+          warning: "the input has no value prop and its native text could not be set from here, so the field may not show the text"
+        };
+      return { filled, element };
     },
     async press(target, options = {}) {
       const { action } = options;
@@ -1475,13 +2088,30 @@ function createScreen(env) {
         throw new Error(`"action" must be an accessibility action name; got ${JSON.stringify(action)}`);
       const found = await resolve(
         target,
-        (f) => action === void 0 ? !!f.press || f.element.kind === "button" : !!f.element.actions?.includes(action),
+        (f) => options.long ? !!longPressFiberOf(f) : action === void 0 ? !!f.press || f.element.kind === "button" || isToggle(f) : !!f.element.actions?.includes(action),
         options
       );
       const via = pressElement(found, options);
       await settle();
       return via === "onPress" ? found.element : { ...found.element, via };
     },
+    /** Sets a Switch, Slider, Picker or SegmentedControl through its onValueChange, and reads the value back. */
+    async setValue(target, value, options = {}) {
+      const found = await resolve(target, (f) => !!f.change, options);
+      const before = valueOf(found);
+      setControlValue(found, value, options);
+      await settle();
+      const again = reread(found);
+      const now2 = valueOf(again);
+      const result = { value: now2, element: again.element };
+      const same = typeof now2 === "number" && typeof value === "number" ? Math.abs(now2 - value) < 1e-6 : now2 === value;
+      if (before !== void 0 && !same && !(found.change && isSlider(found.change)))
+        return {
+          ...result,
+          warning: `the control still shows ${JSON.stringify(now2)}; the app did not apply ${JSON.stringify(value)}`
+        };
+      return result;
+    },
     /**
      * Scrolls the nearest scrollable of a target (or `within`, or the main one
      * on screen) to the target, to either end, or by a distance in points.
@@ -1578,17 +2208,21 @@ function screenTools() {
       run: (text, options) => screen.findText(text, options)
     },
     "screen.snapshot": {
-      description: 'Buttons, inputs, text, and testID or labelled views on screen, with rects and checked/selected/expanded state (a Switch\'s value is checked). `actions` lists the accessibility actions an element handles; one with "activate" and no onPress (a swipe-to-confirm) is a button screen.press can press. Only the focused screen: unfocused tabs and stack screens, content under an open modal, display:none and accessibility-hidden subtrees are left out, and `hidden` counts the elements skipped. {all:true} lists everything, marking off-screen (onScreen:false) and hidden (hidden:true) ones. A WebView registered with the react-native-webview adapter shows as one `webview` element with its name: use webview.* inside it.',
-      run: (options) => screen.snapshot(options)
+      description: 'Buttons, inputs, text, and testID or labelled views on screen, with rects and checked/selected/expanded state (a Switch\'s value is checked). `actions` lists the accessibility actions an element handles; one with "activate" and no onPress (a swipe-to-confirm) is a button screen.press can press. Only the focused screen: unfocused tabs and stack screens, content under an open modal, display:none and accessibility-hidden subtrees are left out, and `hidden` counts the elements skipped. {all:true} lists everything, marking off-screen (onScreen:false) and hidden (hidden:true) ones. A WebView registered with the react-native-webview adapter shows as one `webview` element with its name: use webview.* inside it. Options: {format:"json"|"text"} (the runtime default is JSON with rects; the CLI and the MCP server return the text form unless you pass {format:"json"}). Text is one line per element: kind (or role: switch, checkbox, tab), #testID, text, label, value, state, then `readonly`, `actions=\u2026`, `offscreen`, `hidden`. Lines that repeat get `index=N` (the {index} of the target that names them); a line with no testID, text, label or placeholder gets `@x,y`, the point for {at:[x,y]}. JSON has rects, onScreen:false and hidden:true. {kinds:["button","input"]} keeps only those kinds (kinds are button, input, text, view, webview; a switch or tab is a button); {within: target} keeps only elements under that target in the tree (a target as for screen.press; with several matches pass {testID, index} inside it).',
+      run: (options) => options?.format === "text" ? screen.snapshotText(options) : screen.snapshot(options)
     },
     "screen.fill": {
-      description: `Type into an input, then wait for the render. ${TARGET_HELP} {submit:true} also submits.`,
+      description: `Type into an input, then wait for the render. ${TARGET_HELP} {submit:true} also submits. "" clears it. {type:true} types one character at a time, waiting for a render after each (for debounced or per-character inputs; "\\n" is the Enter key). An input with no value prop gets its native text set; if that cannot be done the reply has a warning.`,
       run: (target, text, options) => screen.fill(target, text, options)
     },
     "screen.press": {
-      description: `Press a button, then wait for the render. ${TARGET_HELP} Disabled elements are refused; {force:true} presses anyway, to see what the app does on tap. {scroll:true} scrolls an off-screen target into view first. With no onPress it sends the "activate" accessibility action, as a screen reader's double tap does (swipe-to-confirm buttons, sliders), and the reply says via:"accessibilityAction:activate". {action:"increment"} (or any name in the element's snapshot \`actions\`) sends that action instead.`,
+      description: `Press a button, then wait for the render. ${TARGET_HELP} Text with no handler of its own presses the nearest ancestor that has one, and the reply says via:"ancestor". Disabled elements are refused; {force:true} presses anyway, to see what the app does on tap. {scroll:true} scrolls an off-screen target into view first. With no onPress it sends the "activate" accessibility action, as a screen reader's double tap does (swipe-to-confirm buttons, sliders), and the reply says via:"accessibilityAction:activate". {action:"increment"} (or any name in the element's snapshot \`actions\`) sends that action instead. A Switch (native switch host or role switch, with onValueChange) is toggled with onValueChange(!value), not the row around it; reply via:"onValueChange". {long:true} long presses: onPressIn, onLongPress, onPressOut (never onPress); an error when there is no onLongPress, on the element or an ancestor. {scroll:true} also pages the largest vertical FlatList/SectionList/FlashList for a row it has not rendered yet (and scrolls back if it finds none; onEndReached may fire). A tap inside a react-native-gesture-handler GestureDetector cannot be pressed from here (its callbacks run on the UI thread): the error says so.`,
       run: (target, options) => screen.press(target, options)
     },
+    "screen.setValue": {
+      description: `Set a Switch, Slider, Picker or SegmentedControl: calls its onValueChange (and a Slider's onSlidingComplete) with the value, waits for the render and reads the value back. A Switch takes true or false, a Slider a number within minimumValue and maximumValue (0 and 1 by default) and on its step (onSlidingStart, onValueChange, onSlidingComplete), a Picker one of its Picker.Item values, a SegmentedControl one of its values (a wrong type or value is an error that lists the options). The reply has \`value\` as the app now shows it, and a warning when that is not what was set (a controlled value the app refused). Disabled controls are refused; {force:true} sets anyway. {scroll:true} scrolls or pages the target into view first (pages the largest vertical list; onEndReached may fire). ${TARGET_HELP}`,
+      run: (target, value, options) => screen.setValue(target, value, options)
+    },
     "screen.scroll": {
       description: `Scroll the nearest ScrollView/FlatList/FlashList, then wait for the render. Takes a target (or {to: target}) to bring into the middle of its scrollable, {toEnd:true}, {toStart:true}, or {by: points} (negative scrolls back); the last argument may be {within: target, index} to name the scrollable (a target inside it, or its testID). Without a target it scrolls the largest scrollable on screen. Only rendered elements can be targeted: rows a FlatList has not rendered yet need {toEnd:true} or {by} first. Returns the offset and, for a target, whether it is now on screen. ${TARGET_HELP}`,
       run: (arg, options) => screen.scroll(arg, options)
@@ -1598,7 +2232,7 @@ function screenTools() {
       run: (target, options) => screen.refresh(target, options)
     },
     "screen.waitFor": {
-      description: "Wait until a target is on screen, or gone with {gone:true}. Matches testID, label, placeholder, then the same joined text screen.snapshot shows. {scroll:true} also accepts a match rendered off screen and scrolls it into view (not with gone). Default timeout 5000 ms; a timeout lists near misses.",
+      description: "Wait until a target is on screen, or gone with {gone:true}. Matches testID, label, placeholder, then the same joined text screen.snapshot shows. {scroll:true} also accepts a match rendered off screen and scrolls it into view, (it does not page lists for rows they have not rendered: wait for the list, then press/fill/setValue with {scroll:true}; not with gone). Default timeout 5000 ms; a timeout lists near misses.",
       run: (target, options) => screen.waitFor(target, options)
     }
   };
@@ -1609,7 +2243,8 @@ function builtinTools(listTools, getTools, logs, getScenarios) {
   return {
     ...bridgeTools(listTools),
     ...appTools(
-      selectReload(globalThis, () => import_react_native2.DevSettings.reload())
+      selectReload(globalThis, () => import_react_native2.DevSettings.reload()),
+      getTools
     ),
     ...logTools(logs),
     ...restoreTools(getTools),
@@ -1858,32 +2493,54 @@ function toJson(value) {
 }
 
 // src/runtime/registry.ts
+var loadSlot = {};
+function ownsKey(slot, key) {
+  if (typeof key !== "string" || key === "") return false;
+  slot.key ?? (slot.key = key);
+  return slot.key === key;
+}
 function unwrap(definition) {
   return typeof definition === "function" ? { run: definition } : definition;
 }
-function createRegistry(getTools, logs, loadId2) {
-  const list = () => Object.entries(getTools()).map(([name, definition]) => ({
+function createRegistry(getTools, logs, loadId2, keySlot = loadSlot) {
+  const list2 = () => Object.entries(getTools()).filter(([name]) => !INTERNAL_TOOLS.includes(name)).map(([name, definition]) => ({
     name,
     description: unwrap(definition).description
   })).sort((a, b) => a.name.localeCompare(b.name));
   async function dispatch(call, from) {
-    const end = logs?.begin(call.tool);
-    const result = await run(call, from).finally(end);
-    const errors = logs?.takeErrors();
-    const stamped = loadId2 ? { ...result, loadId: loadId2, ...pending() } : result;
+    const quiet = call.tool === "bridge.ping" || call.tool === "bridge.pending";
+    const trusted = ownsKey(keySlot, call.journalKey);
+    const end = quiet ? void 0 : logs?.begin(call.tool);
+    const result = INTERNAL_TOOLS.includes(call.tool) && !trusted ? await refused(call, from) : await run(call, from).finally(end);
+    const errors = quiet ? void 0 : logs?.takeErrors();
+    const stamped = loadId2 ? { ...result, loadId: loadId2, ...pending(), ...journal(call, trusted) } : result;
     return errors?.length ? { ...stamped, logs: errors } : stamped;
   }
   function pending() {
     const areas = Object.keys(pendingByArea(getTools()));
     return areas.length ? { pending: areas } : {};
   }
+  function journal(call, trusted) {
+    const rev = journalRev(getTools());
+    const out = rev ? { journal: rev } : {};
+    if (trusted && call.journalAck !== void 0 && call.journalAck !== `${loadId2}:${rev}`)
+      out.journalData = journalByArea(getTools());
+    return out;
+  }
+  const refused = (call, from) => ({
+    id: call.id,
+    from,
+    ok: false,
+    error: `${call.tool} is for a session's own use`,
+    ms: 0
+  });
   async function run(call, from) {
     const t0 = performance.now();
     const ms = () => Math.round((performance.now() - t0) * 100) / 100;
     try {
       const definition = getTools()[call.tool];
       if (!definition) {
-        const known = list().map((t) => t.name).join(", ");
+        const known = list2().map((t) => t.name).join(", ");
         throw new Error(`Unknown tool "${call.tool}". Known: ${known}`);
       }
       const { run: tool, maxArgs } = unwrap(definition);
@@ -1899,7 +2556,7 @@ function createRegistry(getTools, logs, loadId2) {
       return { id: call.id, from, ok: false, error: message2, ms: ms() };
     }
   }
-  return { list, dispatch };
+  return { list: list2, dispatch };
 }
 
 // src/runtime/index.ts