@delacour/warden-e2e 0.13.0 → 0.15.0

package/{chunk-tnr47n9c.mjs → chunk-e3cry5br.mjs}

@@ -236,6 +236,10 @@ function settleDetailOf(outcome) {
 }
 var DEFAULT_SETTLE_QUIET_MS = 250;
 var DEFAULT_SETTLE_TIMEOUT_MS = 3000;
+var HASH_FALLBACK_MIN_QUIET_MS = 500;
+function hashFallbackQuietMs(quietMs) {
+  return Math.max(quietMs, HASH_FALLBACK_MIN_QUIET_MS);
+}
 var DEFAULT_POLL_MS = 50;
 async function settleByHash(poll, deps) {
   const { quietMs, timeoutMs, now, sleep } = deps;
@@ -260,7 +264,7 @@ async function settleByHash(poll, deps) {
       return { quiet: false, waitedMs: t - start };
   }
 }
-function tuple(element) {
+function elementKey(element) {
   const { x, y, width, height } = element.frame;
   return JSON.stringify([
     element.role,
@@ -276,7 +280,7 @@ function tuple(element) {
 function snapshotHash(snapshot) {
   let text = "";
   for (const element of snapshot.flat)
-    text += `${tuple(element)}
+    text += `${elementKey(element)}
 `;
   return Bun.hash(text).toString(36);
 }
@@ -430,6 +434,11 @@ function fieldContent(entry) {
   const text = fieldValue(entry);
   return text === "" ? { kind: "empty" } : { kind: "text", text };
 }
+function maskedReading(entry, text) {
+  const content = fieldContent(entry);
+  const count = content.kind === "dots" ? content.count : 0;
+  return count === graphemes(text) ? text : "\u2022".repeat(count);
+}
 function clearKeyPresses(entry) {
   const content = fieldContent(entry);
   switch (content.kind) {
@@ -479,6 +488,34 @@ function assertDegrees(degrees) {
   }
 }
 
+// ../../packages/e2e/src/screen/degraded-read.ts
+function degradedRead(snapshot) {
+  if (snapshot.fellBackFrom !== undefined) {
+    return { kind: "fallback", from: snapshot.fellBackFrom, backend: snapshot.backend };
+  }
+  const [root, ...others] = snapshot.elements;
+  if (root !== undefined && others.length === 0 && root.children.length === 0) {
+    const { width, height } = root.frame;
+    if (width * height === 0)
+      return { kind: "emptyRoot", backend: snapshot.backend };
+  }
+  return;
+}
+function describeDegraded(read) {
+  if (read.kind === "emptyRoot")
+    return `the ${read.backend} read returned an empty root (backend: ${read.backend})`;
+  return `the read fell back from ${read.from} to ${read.backend} (fellBackFrom: ${read.from}, backend: ${read.backend}), which can drop React Native testIDs`;
+}
+var REACT_NOTES = {
+  unanswered: "the React tree did not answer",
+  "no-devtools": "there is no React tree to ask (no devtools: not a dev client with Metro)",
+  "not-testid": "only a plain getByTestId can be asked of the React tree"
+};
+function degradedFailure(locator, read, waitedMs, react, screen) {
+  const message = `${locator} could not be confirmed within ${waitedMs} ms: bridge degraded, ${describeDegraded(read)}, ` + `and ${REACT_NOTES[react]}. A missing node on such a read is not proof of absence.`;
+  return new E2eError2("READ_DEGRADED", message, screen);
+}
+
 // ../../packages/e2e/src/screen/roles.ts
 var QUERY_ROLES = [
   "button",
@@ -725,7 +762,7 @@ function nonEmpty(value) {
 }
 var MASKED_VALUE = /^[\u2022\u25CF]+$/;
 function isSecure(element, traits) {
-  return element.role === "textfield" && element.value !== undefined && MASKED_VALUE.test(element.value) || element.role === "securefield" || traits.has("password") || traits.has("secure") || element.rawType.toLowerCase().includes("secure");
+  return element.role === "textfield" && element.value !== undefined && MASKED_VALUE.test(element.value) || element.role === "securefield" || traits.has("password") || traits.has("secure") || traits.has("secure-text-field") || element.rawType.toLowerCase().includes("secure");
 }
 function deriveChecked(element, role, spelled, traits, value) {
   if (spelled?.checked !== undefined)
@@ -984,6 +1021,60 @@ async function typeOver(driver, sleep, prepared, text, via) {
   return typeText(driver, sleep, text);
 }
 
+// ../../packages/e2e/src/driver/keyboard-state.ts
+function keyboardElement(snapshot) {
+  const { height } = snapshot.screen;
+  const onScreen = snapshot.flat.filter((e) => e.role === "keyboard" && e.hidden !== true && e.frame.width > 0 && e.frame.height > 0 && (height <= 0 || e.frame.y < height && e.frame.y + e.frame.height > 0));
+  return onScreen.sort((a, b) => b.frame.width * b.frame.height - a.frame.width * a.frame.height)[0];
+}
+function keyboardVisible(snapshot) {
+  return keyboardElement(snapshot) !== undefined;
+}
+function keyboardFrame(snapshot) {
+  return keyboardElement(snapshot)?.frame;
+}
+
+// ../../packages/e2e/src/screen/keyboard-cover.ts
+var COVER_MARGIN = 40;
+var SWIPE_INSET = 12;
+var SCROLL_SWIPE = { durationMs: 350, momentum: false };
+var SCROLL_ROLES = new Set(["scrollview", "list"]);
+function scrollContainer(entry) {
+  for (let node = entry.parent;node !== undefined; node = node.parent) {
+    if (SCROLL_ROLES.has(node.element.role))
+      return node;
+  }
+  return;
+}
+function coverOf(entry, point, snapshot) {
+  const keyboard = keyboardFrame(snapshot);
+  if (keyboard === undefined || entry.element.role === "keyboard")
+    return;
+  const inside = point.x >= keyboard.x && point.x <= keyboard.x + keyboard.width && point.y >= keyboard.y && point.y <= keyboard.y + keyboard.height;
+  if (!inside)
+    return;
+  const container = scrollContainer(entry);
+  const shift = point.y - (keyboard.y - COVER_MARGIN);
+  if (container === undefined)
+    return { top: keyboard.y, shift };
+  const { frame } = container.element;
+  const bottom = Math.min(frame.y + frame.height, keyboard.y);
+  const free = { x: frame.x, y: frame.y, width: frame.width, height: Math.max(0, bottom - frame.y) };
+  return free.height > 2 * SWIPE_INSET ? { top: keyboard.y, scroller: free, shift } : { top: keyboard.y, shift };
+}
+function scrollPath(scroller, shift) {
+  const x = scroller.x + scroller.width / 2;
+  const room = scroller.height - 2 * SWIPE_INSET;
+  const travel = Math.max(1, Math.min(shift, room));
+  const from = scroller.y + scroller.height - SWIPE_INSET;
+  return { from: { x, y: from }, to: { x, y: from - travel } };
+}
+var COVER_SCROLL_SWIPE = SCROLL_SWIPE;
+async function dismissKeyboard(driver) {
+  const done = await driver.dismissKeyboard();
+  return done.success ? { success: true, data: undefined } : done;
+}
+
 // ../../packages/e2e/src/screen/selector.ts
 var VALUE_KEYS = ["id", "label", "text", "role", "value"];
 var KEY_ORDER = [...VALUE_KEYS, "editable", "nth"];
@@ -1534,7 +1625,7 @@ function describeExpression(expr) {
 }
 
 // ../../packages/e2e/src/screen/react-locator.ts
-async function locateByTestIdViaReact(facet, testId, view, options = {}) {
+async function lookUpTestIdViaReact(facet, testId, view, options = {}) {
   const treeOptions = {
     ...view.platform === "android" ? { pixelRatio: view.screen.scale } : {},
     ...options.screenName === undefined ? {} : { screen: options.screenName },
@@ -1544,12 +1635,13 @@ async function locateByTestIdViaReact(facet, testId, view, options = {}) {
   try {
     result = await facet.tree(treeOptions);
   } catch {
-    return [];
+    return { answered: false };
   }
   if (!result.success)
-    return [];
+    return { answered: false };
   const matches = [];
-  for (const component of result.data.components) {
+  const { components } = result.data;
+  for (const component of components) {
     const { testID, rect } = component;
     if (testID === undefined || rect === undefined || !matchesText(testID, testId))
       continue;
@@ -1558,10 +1650,25 @@ async function locateByTestIdViaReact(facet, testId, view, options = {}) {
       tapPoint: { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 },
       source: "react",
       testId: testID,
-      name: component.name
+      name: component.name,
+      ...textOf2(component, components)
     });
   }
-  return matches;
+  return { answered: true, matches };
+}
+function textOf2(component, components) {
+  if (component.text !== undefined)
+    return { text: component.text };
+  const inside = new Set([component.id]);
+  const texts = [];
+  for (const other of components) {
+    if (other.parent === null || !inside.has(other.parent))
+      continue;
+    inside.add(other.id);
+    if (other.text !== undefined)
+      texts.push(other.text);
+  }
+  return texts.length === 0 ? {} : { text: texts.join(" ") };
 }
 function reactTapPoint(match, position) {
   if (position === undefined)
@@ -1569,18 +1676,58 @@ function reactTapPoint(match, position) {
   return { x: match.frame.x + position.x, y: match.frame.y + position.y };
 }
 
+// ../../packages/e2e/src/screen/react-merge.ts
+var EDGE_SLACK = 1.5;
+function sameRect(a, b) {
+  if (a.width <= 0 || a.height <= 0 || b.width <= 0 || b.height <= 0)
+    return false;
+  return Math.abs(a.x - b.x) <= EDGE_SLACK && Math.abs(a.y - b.y) <= EDGE_SLACK && Math.abs(a.x + a.width - (b.x + b.width)) <= EDGE_SLACK && Math.abs(a.y + a.height - (b.y + b.height)) <= EDGE_SLACK;
+}
+function ownText(entry) {
+  return normalizeText(entry.name ?? entry.value ?? "");
+}
+function nodeOfReactMatch(match, index) {
+  const candidates = index.entries.filter((entry) => {
+    const id = entry.element.identifier;
+    return (id === undefined || id === match.testId) && sameRect(entry.element.frame, match.frame);
+  });
+  const text = match.text === undefined ? "" : normalizeText(match.text);
+  const worded = text === "" ? [] : candidates.filter((entry) => ownText(entry) === text);
+  const pool = worded.length > 0 ? worded : candidates;
+  let best;
+  for (const entry of pool)
+    if (best === undefined || entry.depth > best.depth)
+      best = entry;
+  return best;
+}
+function mergeReactMatches(matches, index) {
+  const entries = [];
+  for (const match of matches) {
+    const entry = nodeOfReactMatch(match, index);
+    if (entry === undefined || entries.includes(entry))
+      return;
+    entries.push(entry);
+  }
+  return entries;
+}
+
 // ../../packages/e2e/src/screen/locator.ts
 var WAIT_STATES = ["attached", "detached", "visible", "hidden"];
 var DEFAULT_MAX_SWIPES = 10;
 var VERIFY_MS = 1000;
 var CONFIRM_FLOOR_MS = 500;
 var SCROLL_SETTLE = { quietMs: 150, timeoutMs: 1000 };
+var MAX_COVER_SCROLLS = 3;
+var QUICK_CHECK_WINDOW_MS = 2000;
 function assertOptions(verb, options, allowed) {
   const unknown = Object.keys(options).filter((key) => !allowed.includes(key));
   if (unknown.length > 0) {
     throw new E2eError2("INVALID_ARGUMENT", `${verb} does not take ${unknown.map((key) => `"${key}"`).join(", ")}; it takes ${allowed.join(", ")}`);
   }
 }
+function reactVisible(match, observed) {
+  return match.frame.width > 0 && match.frame.height > 0 && isOnScreen(match.tapPoint, observed.snapshot.screen);
+}
 var REACT_ONLY = "exists only in the React tree, not in the accessibility tree, so only tap() and boundingBox() work on it; " + "expose it to accessibility (accessible, accessibilityLabel) to use anything else";
 function plainTestId(expr) {
   if (expr.kind !== "query" || expr.scope !== undefined || expr.query.kind !== "testId")
@@ -1665,8 +1812,79 @@ class Locator {
     const observed = await this.rt.observe(options);
     return { entries: resolve(this.expr, observed.index), observed };
   }
-  matches() {
-    return this.look();
+  async resolveIn(observed) {
+    const entries = resolve(this.expr, observed.index);
+    if (entries.length > 0)
+      return { kind: "nodes", entries };
+    const read = degradedRead(observed.snapshot);
+    if (read === undefined)
+      return { kind: "nodes", entries };
+    const testId = plainTestId(this.expr);
+    const lookup = testId === undefined ? undefined : await this.rt.reactLookup(testId, observed);
+    if (lookup === undefined || !lookup.answered)
+      return { kind: "unknown", read };
+    if (lookup.matches.length === 0)
+      return { kind: "nodes", entries };
+    const merged = mergeReactMatches(lookup.matches, observed.index);
+    return merged === undefined ? { kind: "react", matches: lookup.matches } : { kind: "nodes", entries: merged };
+  }
+  reactNote() {
+    if (plainTestId(this.expr) === undefined)
+      return "not-testid";
+    return this.rt.hasReactTree() ? "unanswered" : "no-devtools";
+  }
+  degradedFailure(read, waitedMs, snapshot) {
+    const screen = snapshot === undefined ? undefined : this.rt.excerpt(snapshot);
+    return degradedFailure(this.toString(), read, waitedMs, this.reactNote(), screen);
+  }
+  async conclusive(options = {}) {
+    const first = await this.look(options.reuse === undefined ? {} : { reuse: options.reuse });
+    const settled = await this.settled(first.observed);
+    if (settled !== undefined)
+      return settled;
+    const actionMs = this.rt.actionTimeout();
+    const timeoutMs = options.quick === true ? Math.min(actionMs, QUICK_CHECK_WINDOW_MS) : actionMs;
+    let last;
+    const result = await this.rt.poll(async () => {
+      const observation = await this.rt.tryObserve({ reuse: false });
+      if (!observation.ok) {
+        if (!observation.error.retryable)
+          throw new E2eError2("DRIVER", `snapshot failed: ${observation.error.message}`);
+        return { done: false, state: undefined };
+      }
+      const answer = await this.settled(observation.observed);
+      if (answer !== undefined)
+        return { done: true, value: answer };
+      const read = degradedRead(observation.observed.snapshot);
+      if (read !== undefined)
+        last = { read, snapshot: observation.observed.snapshot };
+      return { done: false, state: undefined };
+    }, timeoutMs);
+    if (result.status === "done")
+      return result.value;
+    const fallback = degradedRead(first.observed.snapshot);
+    const read = last?.read ?? fallback;
+    if (read === undefined)
+      throw new E2eError2("TIMEOUT", `${this} could not be read within ${timeoutMs} ms`);
+    throw this.degradedFailure(read, timeoutMs, last?.snapshot ?? first.observed.snapshot);
+  }
+  async settled(observed) {
+    const resolved = await this.resolveIn(observed);
+    if (resolved.kind === "unknown")
+      return;
+    if (resolved.kind === "react")
+      return { entries: [], react: resolved.matches, observed };
+    return { entries: resolved.entries, react: undefined, observed };
+  }
+  async matches() {
+    const { entries, observed } = await this.conclusive();
+    return { entries, observed };
+  }
+  reactOnly(matches, observed) {
+    const [only, ...others] = matches;
+    if (only !== undefined && others.length === 0)
+      return only;
+    throw new E2eError2("LOCATOR_AMBIGUOUS", `${this} matched ${matches.length} components in the React tree`, this.rt.excerpt(observed.snapshot), matches.length);
   }
   async single() {
     const { entries, observed } = await this.matches();
@@ -1686,27 +1904,58 @@ class Locator {
     return this.rt.span(`read.${name}`, run, { detail: () => ({ locator: this.toString() }) });
   }
   count() {
-    return this.traced("count", async () => (await this.matches()).entries.length);
+    return this.traced("count", async () => {
+      const { entries, react } = await this.conclusive({ quick: true });
+      return react?.length ?? entries.length;
+    });
   }
   async all() {
     const count = await this.count();
     return Array.from({ length: count }, (_, index) => this.nth(index));
   }
   text() {
-    return this.traced("text", async () => textOf((await this.single()).entry));
+    return this.traced("text", async () => {
+      const { entries, react, observed } = await this.conclusive();
+      if (react !== undefined)
+        return this.reactText(this.reactOnly(react, observed), observed);
+      if (entries.length === 0 && (await this.reactCandidates(observed)).length > 0) {
+        throw new E2eError2("NOT_ACTIONABLE", `${this} ${REACT_ONLY}`, this.rt.excerpt(observed.snapshot));
+      }
+      return textOf(this.exactlyOne(entries, observed));
+    });
   }
   allTexts() {
-    return this.traced("allTexts", async () => (await this.matches()).entries.map(textOf));
+    return this.traced("allTexts", async () => {
+      const { entries, react, observed } = await this.conclusive();
+      if (react !== undefined)
+        return react.map((match) => this.reactText(match, observed));
+      return entries.map(textOf);
+    });
+  }
+  reactText(match, observed) {
+    if (match.text !== undefined)
+      return normalizeText(match.text);
+    throw new E2eError2("NOT_ACTIONABLE", `${this} ${REACT_ONLY}`, this.rt.excerpt(observed.snapshot));
   }
   value() {
     return this.traced("value", async () => fieldValue((await this.single()).entry));
   }
   isVisible() {
-    return this.traced("isVisible", async () => this.visibleIn((await this.matches()).observed));
+    return this.traced("isVisible", async () => {
+      const { entries, react, observed } = await this.conclusive({ quick: true });
+      if (react !== undefined)
+        return reactVisible(this.reactOnly(react, observed), observed);
+      return entries.length > 0 && this.exactlyOne(entries, observed).visible;
+    });
   }
   read() {
     return this.traced("read", async () => {
-      const { entries, observed } = await this.matches();
+      const { entries, react, observed } = await this.conclusive();
+      if (react !== undefined) {
+        const match = this.reactOnly(react, observed);
+        const visible = reactVisible(match, observed);
+        return match.text === undefined ? { visible } : { visible, text: normalizeText(match.text) };
+      }
       if (entries.length === 0)
         return { visible: false };
       const entry = this.exactlyOne(entries, observed);
@@ -1718,11 +1967,13 @@ class Locator {
       };
     });
   }
-  visibleIn(observed) {
-    const entries = resolve(this.expr, observed.index);
-    if (entries.length === 0)
+  async shownIn(observed) {
+    const resolved = await this.resolveIn(observed);
+    if (resolved.kind === "unknown")
       return false;
-    return this.exactlyOne(entries, observed).visible;
+    if (resolved.kind === "react")
+      return reactVisible(this.reactOnly(resolved.matches, observed), observed);
+    return resolved.entries.length > 0 && this.exactlyOne(resolved.entries, observed).visible;
   }
   async isHidden() {
     return !await this.isVisible();
@@ -1735,7 +1986,7 @@ class Locator {
   }
   boundingBox() {
     return this.traced("boundingBox", async () => {
-      const { entries, observed } = await this.look({ reuse: false });
+      const { entries, observed } = await this.conclusive({ reuse: false });
       if (entries.length === 0) {
         const [only, ...others] = await this.reactCandidates(observed);
         if (only !== undefined && others.length === 0)
@@ -1762,14 +2013,19 @@ class Locator {
         return { done: false, state: undefined };
       }
       const { observed } = observation;
-      const entries = resolve(this.expr, observed.index);
-      const entry = entries.length === 0 ? undefined : this.exactlyOne(entries, observed);
-      return reached(state, entry) ? { done: true, value: true } : { done: false, state: observed.snapshot };
+      const resolved = await this.resolveIn(observed);
+      if (resolved.kind === "unknown")
+        return { done: false, state: { snapshot: observed.snapshot, degraded: resolved.read } };
+      const done = resolved.kind === "react" ? reachedByReact(state, reactVisible(this.reactOnly(resolved.matches, observed), observed)) : reached(state, resolved.entries.length === 0 ? undefined : this.exactlyOne(resolved.entries, observed));
+      return done ? { done: true, value: true } : { done: false, state: { snapshot: observed.snapshot } };
     }, timeoutMs);
     if (result.status === "done")
       return;
+    const last = result.last;
+    if (last?.degraded !== undefined)
+      throw this.degradedFailure(last.degraded, timeoutMs, last.snapshot);
     const message = `${this} did not become ${state} within ${timeoutMs} ms`;
-    throw new E2eError2("TIMEOUT", message, result.last === undefined ? undefined : this.rt.excerpt(result.last));
+    throw new E2eError2("TIMEOUT", message, last === undefined ? undefined : this.rt.excerpt(last.snapshot));
   }
   act(verb, run, suffix = "") {
     return this.rt.step(`${verb} ${this}${suffix}`, run);
@@ -1795,6 +2051,8 @@ class Locator {
     }
     if (seen?.kind === "driver")
       throw new E2eError2("DRIVER", `snapshot kept failing: ${seen.message}`);
+    if (seen?.kind === "degraded")
+      throw this.degradedFailure(seen.read, timeoutMs, seen.snapshot);
     throw new E2eError2("LOCATOR_NOT_FOUND", `${this} matched no elements within ${timeoutMs} ms`, seen === undefined ? undefined : this.rt.excerpt(seen.snapshot));
   }
   async actionableLook(spec, allowReact, anyFrame) {
@@ -1857,6 +2115,26 @@ class Locator {
       return;
     return { entry, observed };
   }
+  async clearOfKeyboard(found, spec, position, timeoutMs) {
+    const coverAt = (at) => coverOf(at.entry, tapPointOf(at.entry, position), at.observed.snapshot);
+    let current = found;
+    let cover = coverAt(current);
+    if (cover === undefined)
+      return found;
+    const { driver } = found.observed;
+    for (let scrolls = 0;cover?.scroller !== undefined && scrolls < MAX_COVER_SCROLLS; scrolls += 1) {
+      const path = scrollPath(cover.scroller, cover.shift);
+      this.rt.drive("scrollIntoView", await driver.swipe(path.from, path.to, COVER_SCROLL_SWIPE));
+      await driver.settle(SCROLL_SETTLE);
+      current = await this.actionable(spec, timeoutMs);
+      cover = coverAt(current);
+    }
+    if (cover === undefined)
+      return current;
+    this.rt.drive("dismissKeyboard", await dismissKeyboard(driver));
+    await driver.settle(SCROLL_SETTLE);
+    return this.actionable(spec, timeoutMs);
+  }
   async tap(options = {}) {
     assertOptions("tap", options, ["position", "timeout", "until", "retries", "windowMs", "pollMs"]);
     const retry = retryPlan(options);
@@ -1866,7 +2144,7 @@ class Locator {
       if (retry === undefined)
         return;
       for (let resent = 0;resent < retry.retries; resent += 1) {
-        const outcome = await this.arrivedWithin(retry, snapshotHash(before));
+        const outcome = await this.arrivedWithin(retry, before);
         if (outcome !== "press-again")
           return;
         before = await this.tapOnce(options);
@@ -1876,19 +2154,31 @@ class Locator {
   async tapOnce(options) {
     const withPosition = options.position !== undefined;
     const spec = { enabled: !withPosition, tapPointOnScreen: !withPosition };
-    const found = (options.until === undefined ? await this.aimFromKept(spec, options.position) : undefined) ?? await this.actionable(spec, options.timeout ?? this.rt.actionTimeout(), true);
+    const timeoutMs = options.timeout ?? this.rt.actionTimeout();
+    const look = (options.until === undefined ? await this.aimFromKept(spec, options.position) : undefined) ?? await this.actionable(spec, timeoutMs, true);
+    const found = "entry" in look ? await this.clearOfKeyboard(look, spec, options.position, timeoutMs) : look;
     const point = "react" in found ? reactTapPoint(found.react, options.position) : tapPointOf(found.entry, options.position);
     const { driver } = found.observed;
+    const aimed = {
+      snapshot: found.observed.snapshot,
+      target: "entry" in found ? found.entry.element : undefined
+    };
     if (!withPosition && "entry" in found && canActOnElements(driver)) {
       if (this.rt.drive("tap", await driver.pressElement(found.entry.element)))
-        return found.observed.snapshot;
+        return aimed;
     }
     this.rt.drive("tap", await driver.tap(point));
-    return found.observed.snapshot;
+    return aimed;
   }
-  async arrivedWithin(plan, pressedOn) {
+  async arrivedWithin(plan, aimed) {
     const { until } = plan;
-    const watch = { pressedOn, started: this.rt.clock.now(), changed: false, unchanged: 0 };
+    const watch = {
+      before: new Set(aimed.snapshot.flat.map(elementKey)),
+      target: aimed.target === undefined ? undefined : elementKey(aimed.target),
+      started: this.rt.clock.now(),
+      changed: false,
+      unchanged: 0
+    };
     const result = await this.rt.poll(async (attempt) => {
       if (typeof until !== "function")
         return this.checkLocatorUntil(until, watch, attempt);
@@ -1909,9 +2199,9 @@ class Locator {
       watch.unchanged = 0;
       return { done: false, state: undefined };
     }
-    if (until.visibleIn(observation.observed))
+    if (await until.shownIn(observation.observed))
       return { done: true, value: "arrived" };
-    if (snapshotHash(observation.observed.snapshot) === watch.pressedOn)
+    if (!reacted(observation.observed.snapshot, watch))
       watch.unchanged += 1;
     else {
       watch.changed = true;
@@ -1923,7 +2213,9 @@ class Locator {
   async longPress(options = {}) {
     assertOptions("longPress", options, ["durationMs", "timeout"]);
     return this.act("longPress", async () => {
-      const { entry, observed } = await this.actionable({ enabled: true, tapPointOnScreen: true }, options.timeout ?? this.rt.actionTimeout());
+      const spec = { enabled: true, tapPointOnScreen: true };
+      const timeoutMs = options.timeout ?? this.rt.actionTimeout();
+      const { entry, observed } = await this.clearOfKeyboard(await this.actionable(spec, timeoutMs), spec, undefined, timeoutMs);
       const opts = options.durationMs === undefined ? undefined : { durationMs: options.durationMs };
       this.rt.drive("longPress", await observed.driver.longPress(tapPointOf(entry), opts));
     });
@@ -1934,18 +2226,18 @@ class Locator {
     return this.act("fill", async () => {
       const budget = this.rt.budget(options.timeout);
       let target = await this.actionable({ enabled: true, tapPointOnScreen: false }, budget.remaining());
+      const verify = !target.entry.secure;
       let firstHeld;
       for (let attempt = 1;; attempt += 1) {
         const point = focusPoint(target.entry.element.frame);
         this.rt.drive("fill", await focusClearType(target.observed.driver, this.pause, point, target.entry, text, clearMethodFor(attempt), process.env, viaFor(attempt, via)));
-        if (target.entry.secure)
+        if (!verify)
           return;
         const outcome = await this.confirm(target, text, budget);
         if (outcome.ok)
           return;
         if (attempt === 2) {
-          const earlier = firstHeld === undefined ? "" : ` (first attempt held ${JSON.stringify(firstHeld)})`;
-          throw new E2eError2("ACTION_FAILED", `${this}: fill did not take: expected ${JSON.stringify(text)} but the field holds ${JSON.stringify(outcome.held)}${earlier}`, outcome.screen);
+          throw new E2eError2("ACTION_FAILED", `${this}: ${fillMismatch(text, target.entry.secure, outcome.held, firstHeld)}`, outcome.screen);
         }
         firstHeld = outcome.held;
         target = await this.actionable({ enabled: true, tapPointOnScreen: false }, budget.remaining());
@@ -2034,10 +2326,17 @@ class Locator {
     return scrollUntilVisible(this.rt, this, options);
   }
   async reactStep(spec, observed, allowReact) {
-    const found = await this.reactCandidates(observed);
+    const read = degradedRead(observed.snapshot);
+    const testId = plainTestId(this.expr);
+    const lookup = testId === undefined ? undefined : await this.rt.reactLookup(testId, observed);
+    const found = lookup?.answered === true ? lookup.matches : [];
     const [match, ...others] = found;
-    if (match === undefined)
+    if (match === undefined) {
+      if (read !== undefined && lookup?.answered !== true) {
+        return { done: false, state: { kind: "degraded", read, snapshot: observed.snapshot } };
+      }
       return { done: false, state: { kind: "none", snapshot: observed.snapshot } };
+    }
     if (!allowReact)
       return { done: false, state: { kind: "react", snapshot: observed.snapshot, matches: found.length } };
     if (others.length > 0) {
@@ -2061,7 +2360,11 @@ class Locator {
   async confirm({ entry, observed }, text, budget) {
     const span = Math.max(budget.remaining(), CONFIRM_FLOOR_MS);
     let lastSeen;
-    const readValue = (found) => text === "" ? fieldValue(found) : rawValue(found);
+    const readValue = (found) => {
+      if (text === "")
+        return fieldValue(found);
+      return found.secure ? maskedReading(found, text) : rawValue(found);
+    };
     const outcome = await confirmFieldValue({
       text,
       now: this.rt.clock.now,
@@ -2119,6 +2422,16 @@ var TAP_WINDOW_MS = 4000;
 var TAP_CHECK_MS = 250;
 var UNCHANGED_CHECKS = 2;
 var UNCHANGED_AFTER_MS = 750;
+function reacted(snapshot, watch) {
+  const now = new Set;
+  for (const element of snapshot.flat) {
+    const key = elementKey(element);
+    if (!watch.before.has(key))
+      return true;
+    now.add(key);
+  }
+  return watch.target !== undefined && !now.has(watch.target);
+}
 function wholeNumber(name, value, atLeast) {
   if (!Number.isInteger(value) || value < atLeast) {
     throw new E2eError2("INVALID_ARGUMENT", `tap ${name} must be an integer of at least ${atLeast}, got ${String(value)}`);
@@ -2161,6 +2474,11 @@ function viaFor(attempt, via) {
 function clearMethodFor(attempt) {
   return attempt === 1 ? "auto" : "counted";
 }
+function fillMismatch(text, secure, held, firstHeld) {
+  const expected = secure ? `${graphemes(text)} characters (secure)` : JSON.stringify(text);
+  const earlier = firstHeld === undefined ? "" : ` (first attempt held ${JSON.stringify(firstHeld)})`;
+  return `fill did not take: expected ${expected} but the field holds ${JSON.stringify(held)}${earlier}`;
+}
 function rawValue(entry) {
   return entry.value ?? (entry.role === "textbox" || entry.role === "searchbox" ? entry.element.text ?? "" : "");
 }
@@ -2176,6 +2494,18 @@ function reached(state, entry) {
       return entry === undefined || !entry.visible;
   }
 }
+function reachedByReact(state, visible) {
+  switch (state) {
+    case "attached":
+      return true;
+    case "detached":
+      return false;
+    case "visible":
+      return visible;
+    case "hidden":
+      return !visible;
+  }
+}
 function blockedReason(entry, spec, observed) {
   if (!entry.visible)
     return "is not visible";
@@ -2189,7 +2519,11 @@ function blockedReason(entry, spec, observed) {
 function isOnScreenEntry(entry, observed) {
   return entry?.visible === true && isOnScreen(tapPointOf(entry), observed.snapshot.screen);
 }
-function scrollGaveUp(target, absent, effort, screen) {
+function scrollGaveUp(target, absent, effort, observed, waitedMs) {
+  const read = absent ? degradedRead(observed.snapshot) : undefined;
+  if (read !== undefined)
+    return target.degradedFailure(read, waitedMs, observed.snapshot);
+  const screen = target.runtime.excerpt(observed.snapshot);
   if (absent)
     return new E2eError2("LOCATOR_NOT_FOUND", `${target} was not found after ${effort}`, screen);
   return new E2eError2("NOT_ACTIONABLE", `${target} is still not on screen after ${effort}`, screen);
@@ -2218,7 +2552,8 @@ async function scrollUntilVisible(rt, target, options = {}) {
       if (isOnScreenEntry(entry, observed))
         return;
       if (swipes >= maxSwipes || budget.remaining() <= 0) {
-        throw scrollGaveUp(target, entry === undefined, `${swipes} swipes ${direction}`, rt.excerpt(observed.snapshot));
+        const effort = `${swipes} swipes ${direction}`;
+        throw scrollGaveUp(target, entry === undefined, effort, observed, budget.total);
       }
       await scrollOnce(rt, observed, direction, options.momentum);
       await observed.driver.settle(SCROLL_SETTLE);
@@ -2288,7 +2623,7 @@ function describeException(details) {
     return String(thrown.value);
   return details.text ?? "JS exception";
 }
-function textOf2(data) {
+function textOf3(data) {
   if (typeof data === "string")
     return data;
   if (data instanceof ArrayBuffer)
@@ -2311,7 +2646,7 @@ function taggedBindingPayload(params) {
   return tagged.success ? { requestId: tagged.data.requestId, payload } : undefined;
 }
 function parseEnvelope(data) {
-  const text = textOf2(data);
+  const text = textOf3(data);
   if (text === undefined)
     return;
   let json;
@@ -4346,6 +4681,14 @@ async function captureNativeLog(target, deps, win) {
   }
 }
 
+// ../../packages/e2e/src/driver/ax-wedge.ts
+function canRecoverAxWedge(driver) {
+  return typeof driver.axWedge === "function";
+}
+function restartedWithin(state, windowMs) {
+  return state.last?.outcome === "restarted" && state.last.agoMs <= windowMs;
+}
+
 // ../../packages/e2e/src/driver/ios/hid-recovery.ts
 import { existsSync as existsSync2 } from "fs";
 
@@ -4421,19 +4764,133 @@ function driverErr(code, message, extra) {
 }
 
 // ../../packages/e2e/src/driver/ios/simd-protocol.ts
+import { z as z7 } from "zod";
+
+// ../../packages/e2e/src/driver/bridge-stall.ts
 import { z as z6 } from "zod";
+var bridgeStallSchema = z6.looseObject({
+  stage: z6.string(),
+  readMs: z6.number().optional(),
+  deadlineMs: z6.number().optional(),
+  guestAgeMs: z6.number().optional(),
+  cold: z6.boolean(),
+  cooldownRemainingMs: z6.number().optional(),
+  probes: z6.number(),
+  recycles: z6.number().optional(),
+  recyclesExhausted: z6.boolean().optional(),
+  axWedge: z6.string().optional(),
+  axWedgeRestarts: z6.number().optional()
+});
+var SPAN_FIELDS = [
+  ["stallStage", "stage"],
+  ["stallReadMs", "readMs"],
+  ["stallDeadlineMs", "deadlineMs"],
+  ["stallGuestAgeMs", "guestAgeMs"],
+  ["stallCold", "cold"],
+  ["stallCooldownMs", "cooldownRemainingMs"],
+  ["stallProbes", "probes"],
+  ["stallRecycles", "recycles"],
+  ["stallRecyclesExhausted", "recyclesExhausted"],
+  ["stallAxWedge", "axWedge"],
+  ["stallAxWedgeRestarts", "axWedgeRestarts"]
+];
+function toBridgeStall(wire) {
+  const stall = { stage: wire.stage, cold: wire.cold, probes: wire.probes };
+  if (wire.readMs !== undefined)
+    stall.readMs = wire.readMs;
+  if (wire.deadlineMs !== undefined)
+    stall.deadlineMs = wire.deadlineMs;
+  if (wire.guestAgeMs !== undefined)
+    stall.guestAgeMs = wire.guestAgeMs;
+  if (wire.cooldownRemainingMs !== undefined)
+    stall.cooldownRemainingMs = wire.cooldownRemainingMs;
+  if (wire.recycles !== undefined)
+    stall.recycles = wire.recycles;
+  if (wire.recyclesExhausted !== undefined)
+    stall.recyclesExhausted = wire.recyclesExhausted;
+  if (wire.axWedge !== undefined)
+    stall.axWedge = wire.axWedge;
+  if (wire.axWedgeRestarts !== undefined)
+    stall.axWedgeRestarts = wire.axWedgeRestarts;
+  return stall;
+}
+function noteBridgeStall(stall) {
+  for (const [key, field] of SPAN_FIELDS) {
+    const value = stall[field];
+    if (value !== undefined)
+      noteSpanDetail(key, value);
+  }
+}
+function bridgeStallFromSpan(detail) {
+  const stage = detail?.stallStage;
+  if (detail === undefined || typeof stage !== "string")
+    return;
+  const stall = {
+    stage,
+    cold: detail.stallCold === true,
+    probes: typeof detail.stallProbes === "number" ? detail.stallProbes : 0
+  };
+  const numbers = [
+    ["stallReadMs", "readMs"],
+    ["stallDeadlineMs", "deadlineMs"],
+    ["stallGuestAgeMs", "guestAgeMs"],
+    ["stallCooldownMs", "cooldownRemainingMs"],
+    ["stallRecycles", "recycles"],
+    ["stallAxWedgeRestarts", "axWedgeRestarts"]
+  ];
+  for (const [key, field] of numbers) {
+    const value = detail[key];
+    if (typeof value === "number")
+      stall[field] = value;
+  }
+  if (typeof detail.stallRecyclesExhausted === "boolean")
+    stall.recyclesExhausted = detail.stallRecyclesExhausted;
+  if (typeof detail.stallAxWedge === "string")
+    stall.axWedge = detail.stallAxWedge;
+  return stall;
+}
+var seconds = (ms) => `${(ms / 1000).toFixed(1)} s`;
+function axWedgeParts(stall) {
+  const parts = [];
+  if (stall.axWedge === "checking")
+    parts.push("both readers silent: checking for a wedged accessibility service");
+  if (stall.axWedgeRestarts !== undefined) {
+    parts.push(`backboardd restarted ${stall.axWedgeRestarts} time${stall.axWedgeRestarts === 1 ? "" : "s"}`);
+  }
+  return parts;
+}
+function formatBridgeStall(stall) {
+  const parts = [`stage ${stall.stage}`];
+  if (stall.readMs !== undefined) {
+    parts.push(stall.deadlineMs === undefined ? `read ${stall.readMs} ms` : `read ${stall.readMs} ms of a ${stall.deadlineMs} ms deadline`);
+  } else if (stall.deadlineMs !== undefined)
+    parts.push(`${stall.deadlineMs} ms deadline`);
+  parts.push(stall.cold ? "cold (first read)" : "warm");
+  if (stall.guestAgeMs !== undefined)
+    parts.push(`guest ${seconds(stall.guestAgeMs)} old`);
+  if (stall.cooldownRemainingMs !== undefined)
+    parts.push(`cooldown ${seconds(stall.cooldownRemainingMs)} left`);
+  parts.push(`${stall.probes} failed bridge reads in a row`);
+  if (stall.recycles !== undefined) {
+    const guests = stall.recycles === 1 ? "guest" : "guests";
+    parts.push(`${stall.recycles} stalled ${guests} recycled${stall.recyclesExhausted === true ? ", none left" : ""}`);
+  }
+  return [...parts, ...axWedgeParts(stall)].join(" \xB7 ");
+}
+
+// ../../packages/e2e/src/driver/ios/simd-protocol.ts
 var protocolVersion = 1;
-var rectSchema2 = z6.object({
-  x: z6.number(),
-  y: z6.number(),
-  width: z6.number(),
-  height: z6.number()
+var rectSchema2 = z7.object({
+  x: z7.number(),
+  y: z7.number(),
+  width: z7.number(),
+  height: z7.number()
 });
-var screenInfoSchema = z6.object({
-  width: z6.number(),
-  height: z6.number(),
-  scale: z6.number(),
-  rotation: z6.number().optional()
+var screenInfoSchema = z7.object({
+  width: z7.number(),
+  height: z7.number(),
+  scale: z7.number(),
+  rotation: z7.number().optional()
 });
 var ROLES = [
   "button",
@@ -4460,29 +4917,29 @@ var ROLES = [
   "application",
   "other"
 ];
-var pointSchema = z6.object({ x: z6.number(), y: z6.number() });
-var wireElementSchema = z6.lazy(() => z6.object({
-  id: z6.string().nullish(),
-  role: z6.enum(ROLES),
-  rawType: z6.string(),
-  label: z6.string().nullish(),
-  identifier: z6.string().nullish(),
-  value: z6.string().nullish(),
-  text: z6.string().nullish(),
-  placeholder: z6.string().nullish(),
+var pointSchema = z7.object({ x: z7.number(), y: z7.number() });
+var wireElementSchema = z7.lazy(() => z7.object({
+  id: z7.string().nullish(),
+  role: z7.enum(ROLES),
+  rawType: z7.string(),
+  label: z7.string().nullish(),
+  identifier: z7.string().nullish(),
+  value: z7.string().nullish(),
+  text: z7.string().nullish(),
+  placeholder: z7.string().nullish(),
   frame: rectSchema2,
   normFrame: rectSchema2.nullish(),
-  traits: z6.array(z6.string()).nullish(),
-  enabled: z6.boolean().nullish(),
-  focused: z6.boolean().nullish(),
-  hidden: z6.boolean().nullish(),
-  selected: z6.boolean().nullish(),
-  checked: z6.boolean().nullish(),
-  hittable: z6.boolean().nullish(),
+  traits: z7.array(z7.string()).nullish(),
+  enabled: z7.boolean().nullish(),
+  focused: z7.boolean().nullish(),
+  hidden: z7.boolean().nullish(),
+  selected: z7.boolean().nullish(),
+  checked: z7.boolean().nullish(),
+  hittable: z7.boolean().nullish(),
   tapPoint: pointSchema.nullish(),
-  pid: z6.number().nullish(),
-  depth: z6.number().nullish(),
-  children: z6.array(wireElementSchema).nullish()
+  pid: z7.number().nullish(),
+  depth: z7.number().nullish(),
+  children: z7.array(wireElementSchema).nullish()
 }));
 var ROLE_SET = new Set(ROLES);
 var isBag = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -4520,33 +4977,33 @@ function wireElementProblem(value) {
   const issue = parsed.error.issues[0];
   return issue ? `${issue.path.join(".") || "(element)"}: ${issue.message}` : "invalid element";
 }
-var wireErrorSchema = z6.object({
-  code: z6.string(),
-  message: z6.string(),
-  retryable: z6.boolean().optional(),
-  detail: z6.unknown().optional()
+var wireErrorSchema = z7.object({
+  code: z7.string(),
+  message: z7.string(),
+  retryable: z7.boolean().optional(),
+  detail: z7.unknown().optional()
 });
-var readyEventSchema = z6.object({
-  event: z6.literal("ready"),
-  protocol: z6.number(),
-  version: z6.string(),
-  udid: z6.string(),
-  hid: z6.object({ transport: z6.string() }),
-  ax: z6.object({ default: z6.string(), bridge: z6.string() }),
+var readyEventSchema = z7.object({
+  event: z7.literal("ready"),
+  protocol: z7.number(),
+  version: z7.string(),
+  udid: z7.string(),
+  hid: z7.object({ transport: z7.string() }),
+  ax: z7.object({ default: z7.string(), bridge: z7.string() }),
   screen: screenInfoSchema
 });
-var logEventSchema = z6.object({
-  event: z6.literal("log"),
-  level: z6.enum(["debug", "info", "warn", "error"]),
-  message: z6.string(),
-  op: z6.string().optional(),
-  id: z6.string().optional()
+var logEventSchema = z7.object({
+  event: z7.literal("log"),
+  level: z7.enum(["debug", "info", "warn", "error"]),
+  message: z7.string(),
+  op: z7.string().optional(),
+  id: z7.string().optional()
 });
-var fatalEventSchema = z6.object({ event: z6.literal("fatal"), error: wireErrorSchema });
-var eventSchema = z6.discriminatedUnion("event", [readyEventSchema, logEventSchema, fatalEventSchema]);
-var responseSchema = z6.discriminatedUnion("ok", [
-  z6.object({ id: z6.string(), ok: z6.literal(true), data: z6.unknown().optional() }),
-  z6.object({ id: z6.string(), ok: z6.literal(false), error: wireErrorSchema })
+var fatalEventSchema = z7.object({ event: z7.literal("fatal"), error: wireErrorSchema });
+var eventSchema = z7.discriminatedUnion("event", [readyEventSchema, logEventSchema, fatalEventSchema]);
+var responseSchema = z7.discriminatedUnion("ok", [
+  z7.object({ id: z7.string(), ok: z7.literal(true), data: z7.unknown().optional() }),
+  z7.object({ id: z7.string(), ok: z7.literal(false), error: wireErrorSchema })
 ]);
 function parseLine(line) {
   let json;
@@ -4562,74 +5019,81 @@ function parseLine(line) {
   const response = responseSchema.safeParse(json);
   return response.success ? { success: true, message: { kind: "response", response: response.data } } : { success: false, reason: `bad response: ${response.error.message}` };
 }
-var healthDataSchema = z6.looseObject({
-  version: z6.string(),
-  udid: z6.string(),
-  hid: z6.object({ transport: z6.string() }),
-  ax: z6.object({
-    default: z6.string(),
-    bridge: z6.enum(["available", "degraded", "missing", "failed"]),
-    error: z6.string().optional(),
-    lastError: z6.object({ message: z6.string(), agoMs: z6.number() }).optional()
+var healthDataSchema = z7.looseObject({
+  version: z7.string(),
+  udid: z7.string(),
+  hid: z7.object({ transport: z7.string() }),
+  ax: z7.object({
+    default: z7.string(),
+    bridge: z7.enum(["available", "degraded", "missing", "failed"]),
+    error: z7.string().optional(),
+    lastError: z7.object({ message: z7.string(), agoMs: z7.number() }).optional()
   }),
   screen: screenInfoSchema,
-  socket: z6.object({ path: z6.string(), clients: z6.number() }).optional(),
-  idb: z6.string().optional(),
-  xcode: z6.string().optional(),
-  builtWith: z6.object({ xcode: z6.string().optional(), idb: z6.string().optional() }).optional(),
-  coreSimulatorVersion: z6.string().nullish(),
-  frontmost: z6.object({ unresolvedAgoMs: z6.number(), method: z6.string() }).optional(),
-  state: z6.string().optional(),
-  uptimeMs: z6.number().optional()
+  socket: z7.object({ path: z7.string(), clients: z7.number() }).optional(),
+  idb: z7.string().optional(),
+  xcode: z7.string().optional(),
+  builtWith: z7.object({ xcode: z7.string().optional(), idb: z7.string().optional() }).optional(),
+  coreSimulatorVersion: z7.string().nullish(),
+  frontmost: z7.object({ unresolvedAgoMs: z7.number(), method: z7.string() }).optional(),
+  bridgeRecycles: z7.object({ count: z7.number(), exhausted: z7.boolean() }).optional(),
+  axWedge: z7.lazy(() => axWedgeDataSchema).optional(),
+  state: z7.string().optional(),
+  uptimeMs: z7.number().optional()
 });
-var snapshotDataSchema = z6.looseObject({
-  backend: z6.enum(["axbridge", "ax", "uiautomator"]),
+var snapshotDataSchema = z7.looseObject({
+  backend: z7.enum(["axbridge", "ax", "uiautomator"]),
   screen: screenInfoSchema,
-  modal: z6.object({ pid: z6.number().optional(), description: z6.string().optional() }).nullish(),
-  truncated: z6.boolean(),
-  elements: z6.array(z6.custom(isWireElement, { error: (issue) => wireElementProblem(issue.input) })),
-  ms: z6.number(),
-  fallback: z6.object({ from: z6.string(), to: z6.string(), reason: z6.string() }).optional(),
-  target: z6.object({ pid: z6.number(), source: z6.string() }).optional(),
-  readMs: z6.number().optional(),
-  nodes: z6.number().optional()
+  modal: z7.object({ pid: z7.number().optional(), description: z7.string().optional() }).nullish(),
+  truncated: z7.boolean(),
+  elements: z7.array(z7.custom(isWireElement, { error: (issue) => wireElementProblem(issue.input) })),
+  ms: z7.number(),
+  fallback: z7.object({
+    from: z7.string(),
+    to: z7.string(),
+    reason: z7.string(),
+    stall: bridgeStallSchema.optional()
+  }).optional(),
+  target: z7.object({ pid: z7.number(), source: z7.string() }).optional(),
+  readMs: z7.number().optional(),
+  nodes: z7.number().optional()
 });
 var elementAtPointDataSchema = wireElementSchema.nullable();
-var screenshotDataSchema = z6.looseObject({
-  path: z6.string().optional(),
-  png: z6.string().optional(),
-  width: z6.number().optional(),
-  height: z6.number().optional()
+var screenshotDataSchema = z7.looseObject({
+  path: z7.string().optional(),
+  png: z7.string().optional(),
+  width: z7.number().optional(),
+  height: z7.number().optional()
 });
-var settleDataSchema = z6.looseObject({
-  quiet: z6.boolean(),
-  waitedMs: z6.number(),
-  via: z6.enum(["stream", "snapshot"]).optional().catch(undefined),
-  reason: z6.string().optional(),
-  frontmostPid: z6.number().optional()
+var settleDataSchema = z7.looseObject({
+  quiet: z7.boolean(),
+  waitedMs: z7.number(),
+  via: z7.enum(["stream", "snapshot"]).optional().catch(undefined),
+  reason: z7.string().optional(),
+  frontmostPid: z7.number().optional()
 });
-var rebindDataSchema = z6.looseObject({
-  bound: z6.boolean(),
-  waitedMs: z6.number(),
-  pid: z6.number().optional(),
-  restarts: z6.number().optional(),
-  recycled: z6.boolean().optional(),
-  reason: z6.string().optional()
+var rebindDataSchema = z7.looseObject({
+  bound: z7.boolean(),
+  waitedMs: z7.number(),
+  pid: z7.number().optional(),
+  restarts: z7.number().optional(),
+  recycled: z7.boolean().optional(),
+  reason: z7.string().optional()
 });
-var alertButtonsDataSchema = z6.object({
-  title: z6.string().optional(),
-  message: z6.string().optional(),
-  buttons: z6.array(wireElementSchema)
+var alertButtonsDataSchema = z7.object({
+  title: z7.string().optional(),
+  message: z7.string().optional(),
+  buttons: z7.array(wireElementSchema)
 }).nullable();
-var frontmostDataSchema = z6.looseObject({
-  frontmost: z6.boolean(),
-  pid: z6.number().optional(),
-  frontmostPid: z6.number().optional()
+var frontmostDataSchema = z7.looseObject({
+  frontmost: z7.boolean(),
+  pid: z7.number().optional(),
+  frontmostPid: z7.number().optional()
 });
-var launchDataSchema = z6.looseObject({ pid: z6.number() });
-var terminateDataSchema = z6.looseObject({ terminated: z6.boolean() });
-var orientationDataSchema = z6.object({
-  orientation: z6.enum([
+var launchDataSchema = z7.looseObject({ pid: z7.number() });
+var terminateDataSchema = z7.looseObject({ terminated: z7.boolean() });
+var orientationDataSchema = z7.object({
+  orientation: z7.enum([
     "portrait",
     "portraitUpsideDown",
     "landscapeLeft",
@@ -4638,7 +5102,18 @@ var orientationDataSchema = z6.object({
     "faceDown",
     "unknown"
   ]),
-  source: z6.enum(["device", "written", "assumed"]).optional()
+  source: z7.enum(["device", "written", "assumed"]).optional()
+});
+var axWedgeDataSchema = z7.looseObject({
+  restarts: z7.number(),
+  maxRestarts: z7.number(),
+  recovering: z7.boolean(),
+  checked: z7.enum(["restarted", "not-wedged", "failed"]).optional(),
+  last: z7.discriminatedUnion("outcome", [
+    z7.looseObject({ outcome: z7.literal("restarted"), agoMs: z7.number(), ms: z7.number().optional() }),
+    z7.looseObject({ outcome: z7.literal("not-wedged"), agoMs: z7.number() }),
+    z7.looseObject({ outcome: z7.literal("failed"), agoMs: z7.number(), error: z7.string() })
+  ]).optional()
 });
 var opSchemas = {
   health: healthDataSchema,
@@ -4651,7 +5126,8 @@ var opSchemas = {
   frontmost: frontmostDataSchema,
   orientation: orientationDataSchema,
   launch: launchDataSchema,
-  terminate: terminateDataSchema
+  terminate: terminateDataSchema,
+  axWedge: axWedgeDataSchema
 };
 function hasOpSchema(op) {
   return Object.hasOwn(opSchemas, op);
@@ -5079,7 +5555,7 @@ async function createSimdClient(factory, options = {}) {
     const transport = session.data.transport;
     if (!transport)
       return { success: false, error: driverError("E_INTERNAL", "warden-simd transport missing") };
-    const timeoutMs = opts.timeoutMs ?? defaultTimeoutMs;
+    const timeoutMs = Math.max(opts.timeoutMs ?? defaultTimeoutMs, opts.minTimeoutMs ?? 0);
     const id = String(++seq);
     const result = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -5342,7 +5818,7 @@ function traceDriver(driver, options) {
 }
 
 // ../../packages/core/src/a11y/a11y.config.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var A11Y_RULE_IDS = [
   "missing-name",
   "image-no-name",
@@ -5355,11 +5831,11 @@ var A11Y_RULE_IDS = [
   "text-clipped",
   "native"
 ];
-var ruleId = z7.enum(A11Y_RULE_IDS);
-var a11yAuditConfigSchema = z7.object({
-  ignore: z7.array(z7.object({ rule: ruleId, identifier: z7.string().min(1).optional() }).strict()).optional(),
-  minSeverity: z7.enum(["error", "warning"]).optional(),
-  rules: z7.array(ruleId).min(1).optional()
+var ruleId = z8.enum(A11Y_RULE_IDS);
+var a11yAuditConfigSchema = z8.object({
+  ignore: z8.array(z8.object({ rule: ruleId, identifier: z8.string().min(1).optional() }).strict()).optional(),
+  minSeverity: z8.enum(["error", "warning"]).optional(),
+  rules: z8.array(ruleId).min(1).optional()
 }).strict();
 function parseA11yAuditEnv(raw) {
   let json;
@@ -5375,7 +5851,7 @@ function parseA11yAuditEnv(raw) {
 }
 
 // ../../packages/core/src/conditions/conditions.config.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../../packages/core/src/duration.ts
 var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
@@ -5417,6 +5893,10 @@ var TEXT_SIZE_NAMES = [
   "accessibility-extra-extra-large",
   "accessibility-extra-extra-extra-large"
 ];
+var KEYBOARD_MODES = ["software", "hardware"];
+var DEFAULT_KEYBOARD_MODE = "software";
+var IME_STASH_ENABLED = "warden_ime_enabled";
+var IME_STASH_DEFAULT = "warden_ime_default";
 var CAMERA_FACINGS = ["back", "front"];
 var CONDITION_AREAS = [
   "network",
@@ -5426,7 +5906,8 @@ var CONDITION_AREAS = [
   "locale",
   "a11y",
   "battery",
-  "camera"
+  "camera",
+  "keyboard"
 ];
 
 // ../../packages/core/src/conditions/network.presets.ts
@@ -5536,51 +6017,52 @@ function appliedA11y(op, applied) {
 
 // ../../packages/core/src/conditions/conditions.config.ts
 var NETWORK_WORDS = ["online", "offline", ...NETWORK_PRESET_NAMES];
-var nonNegative2 = z8.number().nonnegative().finite();
-var customNetworkSchema = z8.object({
+var nonNegative2 = z9.number().nonnegative().finite();
+var customNetworkSchema = z9.object({
   latencyMs: nonNegative2.optional(),
   jitterMs: nonNegative2.optional(),
   downKbps: nonNegative2.optional(),
   upKbps: nonNegative2.optional(),
-  lossPct: z8.number().min(0).max(100).optional()
+  lossPct: z9.number().min(0).max(100).optional()
 }).strict();
-var isoDate = z8.string().refine((v) => !Number.isNaN(Date.parse(v)), { message: "invalid date (use ISO 8601)" });
-var offsetDuration = z8.string().refine((v) => parseDuration(v).success, { message: "invalid duration (use e.g. 2d)" });
-var textSize = z8.union([z8.enum(TEXT_SIZE_NAMES), z8.number().positive().finite()]);
-var a11yConfigSchema = z8.object({
+var isoDate = z9.string().refine((v) => !Number.isNaN(Date.parse(v)), { message: "invalid date (use ISO 8601)" });
+var offsetDuration = z9.string().refine((v) => parseDuration(v).success, { message: "invalid duration (use e.g. 2d)" });
+var textSize = z9.union([z9.enum(TEXT_SIZE_NAMES), z9.number().positive().finite()]);
+var a11yConfigSchema = z9.object({
   textSize: textSize.optional(),
-  boldText: z8.boolean().optional(),
-  contrast: z8.enum(["increased", "normal"]).optional(),
-  reduceMotion: z8.boolean().optional()
+  boldText: z9.boolean().optional(),
+  contrast: z9.enum(["increased", "normal"]).optional(),
+  reduceMotion: z9.boolean().optional()
 }).strict();
-var conditionsConfigSchema = z8.object({
-  network: z8.union([z8.enum(NETWORK_WORDS), customNetworkSchema]).optional(),
-  location: z8.union([
-    z8.enum(["city-run", "city-bike", "freeway"]),
-    z8.object({
-      lat: z8.number().min(-90).max(90),
-      lon: z8.number().min(-180).max(180),
-      altM: z8.number().finite().optional()
+var conditionsConfigSchema = z9.object({
+  network: z9.union([z9.enum(NETWORK_WORDS), customNetworkSchema]).optional(),
+  location: z9.union([
+    z9.enum(["city-run", "city-bike", "freeway"]),
+    z9.object({
+      lat: z9.number().min(-90).max(90),
+      lon: z9.number().min(-180).max(180),
+      altM: z9.number().finite().optional()
     }).strict()
   ]).optional(),
-  clock: z8.union([
+  clock: z9.union([
     isoDate,
-    z8.object({ at: isoDate, frozen: z8.boolean().optional() }).strict(),
-    z8.object({ offset: offsetDuration }).strict()
+    z9.object({ at: isoDate, frozen: z9.boolean().optional() }).strict(),
+    z9.object({ offset: offsetDuration }).strict()
   ]).optional(),
-  permissions: z8.partialRecord(z8.enum(PERMISSION_NAMES), z8.enum(["granted", "denied", "unset"])).optional(),
-  locale: z8.string().min(1).optional(),
-  timezone: z8.string().min(1).optional(),
-  a11y: a11yConfigSchema.optional()
+  permissions: z9.partialRecord(z9.enum(PERMISSION_NAMES), z9.enum(["granted", "denied", "unset"])).optional(),
+  locale: z9.string().min(1).optional(),
+  timezone: z9.string().min(1).optional(),
+  a11y: a11yConfigSchema.optional(),
+  keyboard: z9.enum(KEYBOARD_MODES).optional()
 }).strict();
-var cameraFeedInput = z8.union([
-  z8.string().min(1),
-  z8.object({ path: z8.string().min(1), loop: z8.boolean().optional() }).strict()
+var cameraFeedInput = z9.union([
+  z9.string().min(1),
+  z9.object({ path: z9.string().min(1), loop: z9.boolean().optional() }).strict()
 ]);
-var cameraConfigSchema = z8.object({ back: cameraFeedInput.optional(), front: cameraFeedInput.optional() }).strict().refine((v) => v.back !== undefined || v.front !== undefined, { message: "camera needs a back or a front asset" });
-var cameraFeedsSchema = z8.object({
-  back: z8.object({ path: z8.string().min(1), loop: z8.boolean() }).strict().optional(),
-  front: z8.object({ path: z8.string().min(1), loop: z8.boolean() }).strict().optional()
+var cameraConfigSchema = z9.object({ back: cameraFeedInput.optional(), front: cameraFeedInput.optional() }).strict().refine((v) => v.back !== undefined || v.front !== undefined, { message: "camera needs a back or a front asset" });
+var cameraFeedsSchema = z9.object({
+  back: z9.object({ path: z9.string().min(1), loop: z9.boolean() }).strict().optional(),
+  front: z9.object({ path: z9.string().min(1), loop: z9.boolean() }).strict().optional()
 }).strict();
 function parseCameraFeedsEnv(raw) {
   let json;
@@ -5638,6 +6120,8 @@ function normalizeConditions(config) {
     conditions.locale = config.locale;
   if (config.timezone !== undefined)
     conditions.timezone = config.timezone;
+  if (config.keyboard !== undefined)
+    conditions.keyboard = { mode: config.keyboard };
   if (config.a11y !== undefined) {
     const a11y = { ...config.a11y };
     if (config.a11y.textSize !== undefined) {
@@ -5662,7 +6146,7 @@ function parseConditionsEnv(raw) {
 }
 
 // ../../packages/e2e/src/env.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var ENV_NAMES = {
   udid: "WARDEN_UDID",
   deviceName: "WARDEN_DEVICE_NAME",
@@ -5700,68 +6184,68 @@ var ENV_NAMES = {
 var DEFAULT_TIMEOUT_MS5 = 120000;
 var DEFAULT_ACTION_TIMEOUT_MS = 30000;
 var DEFAULT_ASSERTION_TIMEOUT_MS = 5000;
-var toggle = z9.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
-var millis = z9.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z9.number().int().positive());
-var launchArgs = z9.string().transform((raw, ctx) => {
+var toggle = z10.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
+var millis = z10.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z10.number().int().positive());
+var launchArgs = z10.string().transform((raw, ctx) => {
   try {
-    const parsed = z9.array(z9.string()).safeParse(JSON.parse(raw));
+    const parsed = z10.array(z10.string()).safeParse(JSON.parse(raw));
     if (parsed.success)
       return parsed.data;
   } catch {}
   ctx.addIssue({ code: "custom", message: "must be a JSON array of strings" });
-  return z9.NEVER;
+  return z10.NEVER;
 });
-var conditions = z9.string().transform((raw, ctx) => {
+var conditions = z10.string().transform((raw, ctx) => {
   const parsed = parseConditionsEnv(raw);
   if (parsed.success)
     return parsed.data;
   ctx.addIssue({ code: "custom", message: parsed.error });
-  return z9.NEVER;
+  return z10.NEVER;
 });
-var a11yAudit = z9.string().transform((raw, ctx) => {
+var a11yAudit = z10.string().transform((raw, ctx) => {
   const parsed = parseA11yAuditEnv(raw);
   if (parsed.success)
     return parsed.data;
   ctx.addIssue({ code: "custom", message: parsed.error });
-  return z9.NEVER;
+  return z10.NEVER;
 });
-var cameraFeeds = z9.string().transform((raw, ctx) => {
+var cameraFeeds = z10.string().transform((raw, ctx) => {
   const parsed = parseCameraFeedsEnv(raw);
   if (parsed.success)
     return parsed.data;
   ctx.addIssue({ code: "custom", message: parsed.error });
-  return z9.NEVER;
+  return z10.NEVER;
 });
 var REQUIRED = "required when WARDEN_UDID is set";
-var schema = z9.object({
-  udid: z9.string().min(1),
-  deviceName: z9.string().optional(),
-  platform: z9.enum(["ios", "android"]).default("ios"),
-  bundleId: z9.string({ error: REQUIRED }).min(1, REQUIRED),
-  appPath: z9.string().optional(),
-  metroUrl: z9.string().optional(),
-  devClientScheme: z9.string().min(1).optional(),
+var schema = z10.object({
+  udid: z10.string().min(1),
+  deviceName: z10.string().optional(),
+  platform: z10.enum(["ios", "android"]).default("ios"),
+  bundleId: z10.string({ error: REQUIRED }).min(1, REQUIRED),
+  appPath: z10.string().optional(),
+  metroUrl: z10.string().optional(),
+  devClientScheme: z10.string().min(1).optional(),
   launchArgs: launchArgs.default([]),
-  out: z9.string().optional(),
+  out: z10.string().optional(),
   timeout: millis.default(DEFAULT_TIMEOUT_MS5),
   actionTimeout: millis.default(DEFAULT_ACTION_TIMEOUT_MS),
   assertionTimeout: millis.default(DEFAULT_ASSERTION_TIMEOUT_MS),
-  specsDir: z9.string().optional(),
-  helperDir: z9.string().optional(),
-  simd: z9.string().optional(),
-  simdSocket: z9.string().optional(),
-  iosRunnerSocket: z9.string().optional(),
+  specsDir: z10.string().optional(),
+  helperDir: z10.string().optional(),
+  simd: z10.string().optional(),
+  simdSocket: z10.string().optional(),
+  iosRunnerSocket: z10.string().optional(),
   logTimestamps: toggle.default(false),
-  deviceKind: z9.enum(["physical"]).optional(),
+  deviceKind: z10.enum(["physical"]).optional(),
   iosRunnerRestart: launchArgs.optional(),
   afterReboot: launchArgs.optional(),
-  version: z9.string().optional(),
-  bin: z9.string().optional(),
-  perf: z9.string().optional(),
-  perfBudgets: z9.string().optional(),
+  version: z10.string().optional(),
+  bin: z10.string().optional(),
+  perf: z10.string().optional(),
+  perfBudgets: z10.string().optional(),
   conditions: conditions.optional(),
-  leaseId: z9.string().min(1).optional(),
-  netproxyCommand: launchArgs.pipe(z9.array(z9.string()).min(1)).optional(),
+  leaseId: z10.string().min(1).optional(),
+  netproxyCommand: launchArgs.pipe(z10.array(z10.string()).min(1)).optional(),
   biometrics: toggle.optional(),
   a11yAudit: a11yAudit.optional(),
   cameraFeeds: cameraFeeds.optional()
@@ -5771,7 +6255,7 @@ function defined2(values) {
 }
 function parseArgv(raw) {
   try {
-    const parsed = z9.array(z9.string()).min(1).safeParse(JSON.parse(raw));
+    const parsed = z10.array(z10.string()).min(1).safeParse(JSON.parse(raw));
     if (parsed.success)
       return parsed.data;
   } catch {}
@@ -5841,25 +6325,43 @@ function readEnv(env, opts = {}) {
 // ../../packages/e2e/src/runner/results.ts
 import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname3 } from "path";
-import { z as z10 } from "zod";
-var testStatusSchema = z10.enum(["passed", "failed", "skipped", "timed-out"]);
-var testResultSchema = z10.object({
-  file: z10.string(),
-  title: z10.array(z10.string()),
+import { z as z11 } from "zod";
+var bridgeReadSchema = z11.object({
+  reason: z11.string().optional(),
+  code: z11.string().optional(),
+  stage: z11.string().optional(),
+  readMs: z11.number().optional(),
+  deadlineMs: z11.number().optional(),
+  guestAgeMs: z11.number().optional(),
+  cold: z11.boolean().optional(),
+  cooldownRemainingMs: z11.number().optional(),
+  probes: z11.number().optional(),
+  recycles: z11.number().optional(),
+  recyclesExhausted: z11.boolean().optional()
+});
+var testStatusSchema = z11.enum(["passed", "failed", "skipped", "timed-out"]);
+var testResultSchema = z11.object({
+  file: z11.string(),
+  title: z11.array(z11.string()),
   status: testStatusSchema,
-  durationMs: z10.number(),
-  startedAt: z10.number(),
-  only: z10.boolean().optional(),
-  error: z10.object({
-    message: z10.string(),
-    code: z10.string().optional(),
-    stack: z10.string().optional()
+  durationMs: z11.number(),
+  startedAt: z11.number(),
+  only: z11.boolean().optional(),
+  error: z11.object({
+    message: z11.string(),
+    code: z11.string().optional(),
+    stack: z11.string().optional()
   }).optional(),
-  artifacts: z10.object({ dir: z10.string(), files: z10.array(z10.string()) }).optional(),
-  device: z10.object({
-    udid: z10.string(),
-    platform: z10.enum(["ios", "android"]),
-    name: z10.string().optional()
+  artifacts: z11.object({ dir: z11.string(), files: z11.array(z11.string()) }).optional(),
+  bridge: z11.object({
+    fallbacks: z11.number(),
+    first: bridgeReadSchema,
+    last: bridgeReadSchema
+  }).optional(),
+  device: z11.object({
+    udid: z11.string(),
+    platform: z11.enum(["ios", "android"]),
+    name: z11.string().optional()
   })
 });
 function openResults(path) {
@@ -5995,6 +6497,8 @@ ${read.error}`);
     throw new E2eError2("SESSION", "not running under warden: WARDEN_UDID is not set");
   return read.data;
 }
+var AX_WEDGE_WAIT_MS = 60000;
+var AX_WEDGE_POLL_MS = 1000;
 var WARM_TRIES = 15;
 var WARM_INTERVAL_MS = 2000;
 function createSession(opts = {}) {
@@ -6039,6 +6543,27 @@ function createSession(opts = {}) {
       await sleep(WARM_INTERVAL_MS);
     }
   }
+  let axWedgeRerunFor = 0;
+  async function recoverAxWedge(attemptMs) {
+    const driver = current;
+    if (closing !== undefined || driver === undefined || !canRecoverAxWedge(driver))
+      return false;
+    const sleep = hid?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    let state = await driver.axWedge();
+    let waited = 0;
+    while (state.success && state.data.recovering && waited < AX_WEDGE_WAIT_MS) {
+      await sleep(AX_WEDGE_POLL_MS);
+      waited += AX_WEDGE_POLL_MS;
+      state = await driver.axWedge();
+    }
+    if (!state.success || state.data.restarts <= axWedgeRerunFor)
+      return false;
+    if (!restartedWithin(state.data, attemptMs + waited))
+      return false;
+    axWedgeRerunFor = state.data.restarts;
+    note(`sim ${resolved.deviceName ?? resolved.udid}: accessibility service wedged, warden-simd restarted backboardd (the app was quit); running the test again`);
+    return true;
+  }
   async function recoverRunner(deps, name) {
     if (hidRecovered) {
       note(`iPhone ${name}: the runner connection was lost again after a restart; check the phone and retry`);
@@ -6116,6 +6641,7 @@ function createSession(opts = {}) {
     fixtures: opts.fixtures ?? defaultFixtures,
     nativeLog: opts.nativeLog ?? defaultNativeLog,
     recoverHid: hid === undefined || resolved.platform !== "ios" ? undefined : recoverHid,
+    recoverAxWedge: resolved.platform !== "ios" || resolved.deviceKind === "physical" ? undefined : recoverAxWedge,
     resetDevice,
     log: opts.log ?? writeLine,
     get attempt() {
@@ -6254,6 +6780,9 @@ function attemptSession(session, binding) {
     get recoverHid() {
       return session.recoverHid;
     },
+    get recoverAxWedge() {
+      return session.recoverAxWedge;
+    },
     resetDevice: () => session.resetDevice(),
     get fixtures() {
       return session.fixtures;
@@ -6884,15 +7413,15 @@ function runAudit(snapshot, platform, opts = {}) {
 function failing(result, minSeverity = "error") {
   return result.issues.filter((i) => SEVERITY_RANK[i.severity] >= SEVERITY_RANK[minSeverity]);
 }
-function elementKey(i) {
+function elementKey2(i) {
   return i.identifier ?? i.elementId;
 }
 function mergeIssues(base, extra, skipped = []) {
   const issues = [...base.issues];
   const added = [];
   for (const e of extra) {
-    const key = elementKey(e);
-    const idx = issues.findIndex((i) => key !== undefined && elementKey(i) === key && (e.wcag !== undefined ? i.wcag === e.wcag : i.rule === e.rule && i.message === e.message));
+    const key = elementKey2(e);
+    const idx = issues.findIndex((i) => key !== undefined && elementKey2(i) === key && (e.wcag !== undefined ? i.wcag === e.wcag : i.rule === e.rule && i.message === e.message));
     const hit = idx === -1 ? undefined : issues[idx];
     if (hit === undefined) {
       added.push(e);
@@ -7235,6 +7764,12 @@ function createDeviceA11y(deps) {
       const merged = await withA11yRead(driver, taken.data);
       return renderA11yScreen(merged.success ? merged.data : taken.data);
     },
+    async keyboardVisible() {
+      const state = await settled(() => driver.keyboardState(), "keyboardState", signal());
+      if (!state.success)
+        throw toE2eError(state.error, "read the keyboard");
+      return state.data.visible;
+    },
     assertionTimeout: () => env.assertionTimeoutMs,
     step: (label, fn) => deps.step === undefined ? fn() : deps.step(label, fn)
   };
@@ -8030,6 +8565,7 @@ var KNOWN_AREAS = new Set([
   "locale",
   "a11y",
   "battery",
+  "keyboard",
   "camera"
 ]);
 
@@ -8403,6 +8939,8 @@ function createDeviceConditions(deps) {
   let localeDirty = false;
   let a11yDirty = false;
   let batteryDirty = false;
+  let keyboardDirty = false;
+  let currentKeyboard = DEFAULT_KEYBOARD_MODE;
   let cameraDirty = false;
   let currentCamera = {};
   const permissionStates = new Map;
@@ -8779,6 +9317,28 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
     emit({ area: "battery", value });
     return state;
   }
+  const ownsDevice = recorder !== undefined && env.deviceKind !== "physical";
+  const keyboardGoal = baseline.keyboard?.mode ?? DEFAULT_KEYBOARD_MODE;
+  async function applyKeyboard(input) {
+    const mode = input === "toggle" ? currentKeyboard === "software" ? "hardware" : "software" : input;
+    if (!KEYBOARD_MODES.includes(mode)) {
+      throw invalid2(`unknown keyboard mode "${String(input)}" (use software, hardware or toggle)`);
+    }
+    keyboardDirty = true;
+    const run = settingOp("keyboard");
+    const state = await call("keyboard", () => run(mode));
+    currentKeyboard = mode;
+    const value = {
+      mode,
+      ...state.previousIme === undefined ? {} : { previousIme: state.previousIme }
+    };
+    if (mode === DEFAULT_KEYBOARD_MODE)
+      recorder?.settle("keyboard", value, true);
+    else
+      recorder?.record("keyboard", value);
+    emit({ area: "keyboard", value });
+    return state;
+  }
   const home = deps.wardenHome ?? wardenHome(process.env);
   async function applyCamera(next) {
     cameraDirty = true;
@@ -8881,7 +9441,7 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
       throw new E2eError2("ACTION_FAILED", `a network flap or timeline stopped on its own after failing: ${failures[0]}`);
     }
   }
-  const declared = baseline.network !== undefined || baseline.location !== undefined || baseline.clock !== undefined || baseline.permissions !== undefined || baseline.locale !== undefined || baseline.timezone !== undefined || baseline.a11y !== undefined || env.cameraFeeds !== undefined;
+  const declared = baseline.network !== undefined || baseline.location !== undefined || baseline.clock !== undefined || baseline.permissions !== undefined || baseline.locale !== undefined || baseline.timezone !== undefined || baseline.a11y !== undefined || baseline.keyboard !== undefined || ownsDevice || env.cameraFeeds !== undefined;
   async function applyBaselinePermissions() {
     if (baseline.permissions === undefined)
       return;
@@ -8918,6 +9478,10 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
     async () => {
       if (env.cameraFeeds !== undefined)
         await applyCamera(baselineCamera());
+    },
+    async () => {
+      if (baseline.keyboard !== undefined || ownsDevice)
+        await applyKeyboard(keyboardGoal);
     }
   ];
   const teardownSteps = [
@@ -8957,6 +9521,13 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
         batteryDirty = false;
       }
     },
+    {
+      dirty: () => keyboardDirty,
+      run: async () => {
+        await applyKeyboard(keyboardGoal);
+        keyboardDirty = false;
+      }
+    },
     {
       dirty: () => cameraDirty,
       run: async () => {
@@ -8967,7 +9538,7 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
   ];
   const internals = {
     declared,
-    dirty: () => networkDirty || locationDirty || clockDirty || permissionsDirty || localeDirty || a11yDirty || batteryDirty || cameraDirty || runs.size > 0,
+    dirty: () => networkDirty || locationDirty || clockDirty || permissionsDirty || localeDirty || a11yDirty || batteryDirty || keyboardDirty || cameraDirty || runs.size > 0,
     wantsInject: () => baseline.network !== undefined || baseline.clock !== undefined || currentNetwork.kind !== "online" || currentClock.kind !== "real",
     async applyBaseline() {
       for (const step of baselineSteps)
@@ -8980,6 +9551,7 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
       localeDirty = false;
       a11yDirty = false;
       batteryDirty = false;
+      keyboardDirty = false;
     },
     async teardown() {
       const errors = [];
@@ -9008,6 +9580,7 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
     locale: applyLocale,
     a11y: applyA11y,
     battery: applyBattery,
+    keyboard: applyKeyboard,
     camera: cameraApi,
     memoryWarning: async (options) => {
       const op = settingOp("memoryWarning");
@@ -9327,6 +9900,6 @@ function onlyWasSeen() {
 
 // ../../packages/e2e/src/version.ts
 var WORKSPACE_VERSION = "0.0.0-workspace";
-var WARDEN_E2E_VERSION2 = "0.13.0";
+var WARDEN_E2E_VERSION2 = "0.15.0";
 
-export { E2eError2, registerA11yTarget, a11yTargetOf, canActOnElements, noteSpanDetail, addSpanDetail, canObserve, canDetectAlerts, settleDetailOf, DEFAULT_SETTLE_QUIET_MS, DEFAULT_SETTLE_TIMEOUT_MS, settleByHash, snapshotHash, ok, err, swipeVector, screenRect, fieldValue, PINCH_MS, ROTATE_MS, PATH_MS, centreOf, pinchRadius, rotateRadius, requireGesture, assertScale, assertDegrees, isInteractiveRole, resolveRole, normalizeText, matchesText, indexSnapshot, testIdQuery, textQuery, roleQuery, selectorExpression, renderSnapshot, renderHeader, resolve, locateByTestIdViaReact, isLocator, Locator, pickOne, textOf, scrollUntilVisible, formatNativeTail, realNativeLogDeps, captureNativeLog, bunExec, execError, driverError, driverErr, logEventSchema, fatalEventSchema, responseSchema, mapWireError, createLineSplitter, encodeRequest, bunSpawn, stdioTransport, socketTransport, createSimdClient, spawnSimd, connectSimd, isRecoverableLoss, parseDuration, CAMERA_FACINGS, CONDITION_AREAS, resolveNetwork, resolveTextSize, androidFontScale, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, peekSession, accessibleName, announce, failing, formatIssues, toE2eError, settled, unwrap, parseUiadA11yEvents, parseInjectEvents, withA11yRead, renderA11yScreen, createDeviceA11y, IOS_DEVICE_CAPABILITIES, sniffCameraMedia, cameraFeedDir, clearCameraFeeds, isLeaseAlive, processAlive, describeOwner, isPhysicalIosId, wardenHome, defaultDbPath, ownerKey, openStore, callerFile, formatCoord, DEFAULT_SPEED_MPS, DEFAULT_INTERVAL_S, realTickerClock, startRouteTicker, startFlap, registerConditions, conditionsOf, conditionSinkFor, createDeviceConditions, parseBudgets, createDevicePerf, perfStartFor, spawnWarden, hash6, attemptDir, screenshotPath, specIdOf, BUN_TIMEOUT_MARGIN_MS2, ownHook, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION2 };
+export { E2eError2, registerA11yTarget, a11yTargetOf, canActOnElements, noteSpanDetail, addSpanDetail, canObserve, canDetectAlerts, settleDetailOf, DEFAULT_SETTLE_QUIET_MS, DEFAULT_SETTLE_TIMEOUT_MS, hashFallbackQuietMs, settleByHash, snapshotHash, ok, err, swipeVector, screenRect, isOnScreen, fieldValue, PINCH_MS, ROTATE_MS, PATH_MS, centreOf, pinchRadius, rotateRadius, requireGesture, assertScale, assertDegrees, isInteractiveRole, resolveRole, normalizeText, matchesText, indexSnapshot, keyboardVisible, testIdQuery, textQuery, roleQuery, selectorExpression, renderSnapshot, renderHeader, lookUpTestIdViaReact, isLocator, Locator, pickOne, textOf, scrollUntilVisible, formatNativeTail, realNativeLogDeps, captureNativeLog, bunExec, execError, driverError, driverErr, bridgeStallSchema, toBridgeStall, noteBridgeStall, bridgeStallFromSpan, formatBridgeStall, logEventSchema, fatalEventSchema, responseSchema, mapWireError, createLineSplitter, encodeRequest, bunSpawn, stdioTransport, socketTransport, createSimdClient, spawnSimd, connectSimd, isRecoverableLoss, parseDuration, KEYBOARD_MODES, DEFAULT_KEYBOARD_MODE, IME_STASH_ENABLED, IME_STASH_DEFAULT, CAMERA_FACINGS, CONDITION_AREAS, resolveNetwork, resolveTextSize, androidFontScale, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, peekSession, accessibleName, announce, failing, formatIssues, toE2eError, settled, unwrap, parseUiadA11yEvents, parseInjectEvents, withA11yRead, renderA11yScreen, createDeviceA11y, IOS_DEVICE_CAPABILITIES, sniffCameraMedia, cameraFeedDir, clearCameraFeeds, isLeaseAlive, processAlive, describeOwner, isPhysicalIosId, wardenHome, defaultDbPath, ownerKey, openStore, callerFile, formatCoord, DEFAULT_SPEED_MPS, DEFAULT_INTERVAL_S, realTickerClock, startRouteTicker, startFlap, registerConditions, conditionsOf, conditionSinkFor, createDeviceConditions, parseBudgets, createDevicePerf, perfStartFor, spawnWarden, hash6, attemptDir, screenshotPath, specIdOf, BUN_TIMEOUT_MARGIN_MS2, ownHook, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION2 };