@delacour/warden-e2e 0.0.0-stage → 0.2.0

package/preload.mjs

@@ -0,0 +1,4788 @@
+// @bun
+import {
+  E2eError2,
+  noteSpanDetail,
+  addSpanDetail,
+  canObserve,
+  canDetectAlerts,
+  settleDetailOf,
+  DEFAULT_SETTLE_QUIET_MS,
+  DEFAULT_SETTLE_TIMEOUT_MS,
+  settleByHash,
+  snapshotHash,
+  ok,
+  err,
+  swipeVector,
+  screenRect,
+  PINCH_MS,
+  ROTATE_MS,
+  PATH_MS,
+  centreOf,
+  pinchRadius,
+  rotateRadius,
+  requireGesture,
+  assertScale,
+  assertDegrees,
+  isInteractiveRole,
+  resolveRole,
+  indexSnapshot,
+  testIdQuery,
+  textQuery,
+  roleQuery,
+  selectorExpression,
+  renderSnapshot,
+  renderHeader,
+  locateByTestIdViaReact,
+  isLocator,
+  Locator,
+  scrollUntilVisible,
+  bunExec,
+  execError,
+  driverError,
+  driverErr,
+  logEventSchema,
+  fatalEventSchema,
+  responseSchema,
+  mapWireError,
+  encodeRequest,
+  bunSpawn,
+  stdioTransport,
+  spawnSimd,
+  connectSimd,
+  ENV_NAMES,
+  DEFAULT_ASSERTION_TIMEOUT_MS,
+  readEnv,
+  setDefaultHidRecovery,
+  setDefaultNativeLog,
+  setDefaultDriverFactory,
+  hasDefaultDriverFactory,
+  setDefaultFixtureFactory,
+  hasDefaultFixtureFactory,
+  getSession,
+  parseBudgets,
+  createDevicePerf,
+  spawnWarden,
+  screenshotPath,
+  realNativeLogDeps,
+  BUN_TIMEOUT_MARGIN_MS2,
+  onlyWasSeen,
+  WORKSPACE_VERSION,
+  WARDEN_E2E_VERSION2
+} from "./chunk-7ns30pbp.mjs";
+
+// ../../packages/e2e/src/preload.ts
+import { afterAll, setDefaultTimeout } from "bun:test";
+
+// ../../packages/core/src/providers/android.ts
+import { join as join2 } from "path";
+
+// ../../packages/core/src/config.defaults.ts
+var DEFAULT_TTL_MS = 30 * 60000;
+var BARE_CLAIM_AGENT_TTL_MS = 5 * 60000;
+var DEFAULT_IDLE_MS = 20 * 60000;
+var DEFAULT_READY_TIMEOUT_MS = 5 * 60000;
+var DEFAULT_JOB_TIMEOUT_MS = 10 * 60000;
+
+// ../../packages/core/src/store.ts
+import { dirname, join } from "path";
+function wardenHome(env = process.env) {
+  if (env.WARDEN_HOME)
+    return env.WARDEN_HOME;
+  return join(env.HOME ?? "~", ".warden");
+}
+
+// ../../packages/core/src/providers/android.ts
+function androidTools(env) {
+  const sdk = env.ANDROID_HOME || env.ANDROID_SDK_ROOT;
+  if (!sdk)
+    return { adb: "adb", emulator: "emulator" };
+  return { adb: join2(sdk, "platform-tools", "adb"), emulator: join2(sdk, "emulator", "emulator") };
+}
+var avdLists = new WeakMap;
+
+// ../../packages/e2e/src/driver/android/android-driver.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+
+// ../../packages/e2e/src/driver/gesture-geometry.ts
+var GESTURE_FRAME_MS = 16;
+var GESTURE_MAX_FRAMES = 1000;
+var GESTURE_MAX_MS = 60000;
+var GESTURE_MAX_POINTERS = 2;
+var DEFAULT_GESTURE_MS = 300;
+var DEFAULT_PINCH_MS = 400;
+var DEFAULT_ROTATE_MS = 500;
+var DEFAULT_RADIUS = 100;
+var TWO_FINGER_RELEASE_MS = 50;
+var ARC_STEP_DEGREES = 5;
+function bad(message) {
+  return { success: false, error: driverError("E_BAD_REQUEST", message) };
+}
+function finite(value) {
+  return Number.isFinite(value);
+}
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function nonNegative(name, value) {
+  if (value === undefined)
+    return;
+  return finite(value) && value >= 0 ? undefined : `${name} must be a finite number >= 0`;
+}
+function timeByLength(points, durationMs) {
+  if (points.length === 1)
+    return points.map((p) => ({ x: p.x, y: p.y, t: 0 }));
+  const lengths = [0];
+  for (let i = 1;i < points.length; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    lengths.push(lengths[i - 1] + Math.hypot(b.x - a.x, b.y - a.y));
+  }
+  const total = lengths.at(-1);
+  return points.map((p, i) => ({
+    x: p.x,
+    y: p.y,
+    t: total > 0 ? lengths[i] / total * durationMs : i / (points.length - 1) * durationMs
+  }));
+}
+function positionAt(path, at) {
+  let i = 0;
+  while (i < path.length - 1 && path[i + 1].t <= at)
+    i++;
+  const from = path[i];
+  const to = path[i + 1];
+  if (!to)
+    return { x: from.x, y: from.y };
+  const f = (at - from.t) / (to.t - from.t);
+  return { x: from.x + (to.x - from.x) * f, y: from.y + (to.y - from.y) * f };
+}
+function checkOptions(opts, timed) {
+  if (timed && opts?.durationMs !== undefined)
+    return "`durationMs` is for untimed paths; these carry `t`";
+  const durationMs = opts?.durationMs ?? DEFAULT_GESTURE_MS;
+  if (!finite(durationMs) || durationMs <= 0)
+    return "durationMs must be a finite number > 0";
+  const problem = nonNegative("holdMs", opts?.holdMs) ?? nonNegative("releaseMs", opts?.releaseMs);
+  if (problem)
+    return problem;
+  return { durationMs, holdMs: opts?.holdMs ?? 0, releaseMs: opts?.releaseMs ?? 0, timed };
+}
+function checkInput(paths, opts, maxPointers) {
+  if (paths.length < 1 || paths.length > GESTURE_MAX_POINTERS) {
+    return `a gesture takes 1 to ${GESTURE_MAX_POINTERS} finger paths, got ${paths.length}`;
+  }
+  if (paths.length > maxPointers) {
+    return driverError("E_UNSUPPORTED", `this driver takes at most ${maxPointers} finger(s), got ${paths.length}`);
+  }
+  const points = paths.flatMap((path) => path.points);
+  if (paths.some((path) => path.points.length === 0))
+    return "every finger path needs at least one point";
+  if (points.some((p) => !finite(p.x) || !finite(p.y)))
+    return "gesture points must be finite";
+  const timed = points.filter((p) => p.t !== undefined).length;
+  if (timed !== 0 && timed !== points.length)
+    return "give `t` on every point of a gesture or on none";
+  return checkOptions(opts, timed > 0);
+}
+function timedFinger(path) {
+  const finger = path.points.map((p) => ({ x: p.x, y: p.y, t: p.t }));
+  if (finger[0]?.t !== 0)
+    return "a timed path starts at t = 0 (touch-down)";
+  if (finger.some((p, i) => !finite(p.t) || i > 0 && p.t < finger[i - 1].t)) {
+    return "`t` must be finite and must not decrease along a path";
+  }
+  return finger;
+}
+function planGesture(paths, opts, maxPointers) {
+  const timing = checkInput(paths, opts, maxPointers);
+  if (typeof timing === "string")
+    return bad(timing);
+  if ("code" in timing)
+    return { success: false, error: timing };
+  const { durationMs, holdMs, releaseMs } = timing;
+  const fingers = [];
+  for (const path of paths) {
+    const finger = timing.timed ? timedFinger(path) : timeByLength(path.points, durationMs);
+    if (typeof finger === "string")
+      return bad(finger);
+    fingers.push(finger);
+  }
+  const span = Math.max(...fingers.map((finger) => finger.at(-1).t));
+  if (span + holdMs + releaseMs > GESTURE_MAX_MS)
+    return bad(`a gesture lasts at most ${GESTURE_MAX_MS} ms`);
+  const intervals = span === 0 ? 0 : Math.min(GESTURE_MAX_FRAMES, Math.ceil(span / GESTURE_FRAME_MS));
+  const frameMs = intervals === 0 ? GESTURE_FRAME_MS : span / intervals;
+  const frames = fingers.map((finger) => Array.from({ length: intervals + 1 }, (_, k) => {
+    const p = positionAt(finger, k === intervals ? span : k * frameMs);
+    return { x: round(p.x), y: round(p.y) };
+  }));
+  return { success: true, data: { paths: frames, frameMs, holdMs, releaseMs, totalMs: span + holdMs + releaseMs } };
+}
+function twoFingerPaths(center, spec, durationMs) {
+  const scale = spec.scale ?? 1;
+  const degrees = spec.degrees ?? 0;
+  const steps = degrees === 0 ? 1 : Math.max(1, Math.ceil(Math.abs(degrees) / ARC_STEP_DEGREES));
+  const a = [];
+  const b = [];
+  for (let i = 0;i <= steps; i++) {
+    const u = i / steps;
+    const theta = ((spec.angle ?? 0) + degrees * u) * Math.PI / 180;
+    const r = spec.radius * (1 + (scale - 1) * u);
+    const dx = r * Math.cos(theta);
+    const dy = r * Math.sin(theta);
+    const t = u * durationMs;
+    a.push({ x: center.x - dx, y: center.y - dy, t });
+    b.push({ x: center.x + dx, y: center.y + dy, t });
+  }
+  return [{ points: a }, { points: b }];
+}
+function twoFinger(center, spec, opts, defaultRadius, defaultMs) {
+  if (!finite(center.x) || !finite(center.y))
+    return bad("the centre must be finite");
+  const radius = opts?.radius ?? defaultRadius;
+  if (!finite(radius) || radius <= 0)
+    return bad("radius must be a finite number > 0");
+  if (opts?.angle !== undefined && !finite(opts.angle))
+    return bad("angle must be finite");
+  const durationMs = opts?.durationMs ?? defaultMs;
+  if (!finite(durationMs) || durationMs <= 0)
+    return bad("durationMs must be a finite number > 0");
+  const paths = twoFingerPaths(center, { radius, ...spec, ...opts?.angle !== undefined ? { angle: opts.angle } : {} }, durationMs);
+  return planGesture(paths, { releaseMs: TWO_FINGER_RELEASE_MS }, 2);
+}
+function pinchPlan(center, scale, opts, defaultRadius) {
+  if (!finite(scale) || scale <= 0)
+    return bad("scale must be a finite number > 0");
+  return twoFinger(center, { scale }, opts, defaultRadius, DEFAULT_PINCH_MS);
+}
+function rotatePlan(center, degrees, opts, defaultRadius) {
+  if (!finite(degrees))
+    return bad("degrees must be finite");
+  return twoFinger(center, { degrees }, opts, defaultRadius, DEFAULT_ROTATE_MS);
+}
+
+// ../../packages/e2e/src/driver/android/adb-session.ts
+function spawnAdb(argv, env) {
+  const proc = Bun.spawn(argv, {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "ignore",
+    ...env ? { env: { ...process.env, ...env } } : {}
+  });
+  return {
+    write(data) {
+      proc.stdin.write(data);
+      proc.stdin.flush();
+    },
+    stdout: proc.stdout,
+    kill() {
+      proc.kill("SIGKILL");
+    },
+    exited: proc.exited
+  };
+}
+var DEFAULT_ADB_TIMEOUT_MS = 1e4;
+var MAX_CONSECUTIVE_CRASHES = 2;
+function openAdbSession(options) {
+  const { adb, serial, log } = options;
+  const spawn = options.spawn ?? ((argv) => spawnAdb(argv));
+  const nonce = Math.random().toString(36).slice(2, 8);
+  let seq = 0;
+  let live;
+  let current;
+  let crashes = 0;
+  let closed = false;
+  let tail = Promise.resolve();
+  function check(l) {
+    if (!current)
+      return;
+    const start = l.buffer.indexOf(current.prefix);
+    if (start < 0)
+      return;
+    const afterPrefix = start + current.prefix.length;
+    const m = /^(\d+)__(\r?\n)?/.exec(l.buffer.slice(afterPrefix));
+    if (!m)
+      return;
+    const stdout = l.buffer.slice(0, start);
+    l.buffer = l.buffer.slice(afterPrefix + m[0].length);
+    const settle = current.settle;
+    current = undefined;
+    settle({ kind: "done", result: { stdout, exitCode: Number(m[1]) } });
+  }
+  function onDeath(l) {
+    if (l.dead)
+      return;
+    l.dead = true;
+    if (live === l)
+      live = undefined;
+    crashes++;
+    log?.(`adb[${serial}] shell died (consecutive crashes: ${crashes})`);
+    if (current) {
+      const settle = current.settle;
+      current = undefined;
+      settle({ kind: "crashed", tail: l.buffer.slice(-200) });
+    }
+  }
+  async function pump(l) {
+    const decoder = new TextDecoder;
+    try {
+      for await (const chunk of l.proc.stdout) {
+        if (l.dead)
+          return;
+        l.buffer += decoder.decode(chunk, { stream: true });
+        check(l);
+      }
+    } catch {}
+    onDeath(l);
+  }
+  function start() {
+    if (crashes >= MAX_CONSECUTIVE_CRASHES) {
+      return {
+        code: "E_HELPER_CRASHED",
+        message: `adb shell for ${serial} keeps dying; giving up (open a new session)`
+      };
+    }
+    let proc;
+    try {
+      proc = spawn([adb, "-s", serial, "shell"]);
+    } catch (error) {
+      return {
+        code: "E_HELPER_MISSING",
+        message: `cannot spawn \`${adb}\`: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    const l = { proc, buffer: "", dead: false };
+    live = l;
+    pump(l);
+    return l;
+  }
+  async function execute(cmd, timeoutMs) {
+    if (closed)
+      return driverErr("E_INTERNAL", `adb session for ${serial} is closed`);
+    const started = live && !live.dead ? live : start();
+    if ("code" in started)
+      return driverErr(started.code, started.message);
+    const l = started;
+    seq++;
+    const prefix = `__WDN_${nonce}x${seq}_`;
+    const line = `(${cmd}) 2>&1 </dev/null; echo "${prefix}$?__"
+`;
+    const t0 = Date.now();
+    const outcome = await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (current?.prefix !== prefix)
+          return;
+        current = undefined;
+        resolve({ kind: "timeout" });
+      }, timeoutMs);
+      current = {
+        prefix,
+        settle: (o) => {
+          clearTimeout(timer);
+          resolve(o);
+        }
+      };
+      try {
+        l.proc.write(line);
+      } catch {
+        onDeath(l);
+      }
+    });
+    addSpanDetail("adbMs", Date.now() - t0);
+    addSpanDetail("adbCalls", 1);
+    if (outcome.kind === "done") {
+      crashes = 0;
+      log?.(`adb[${serial}] ${cmd} -> ${outcome.result.exitCode} in ${Date.now() - t0}ms`);
+      return { success: true, data: outcome.result };
+    }
+    if (outcome.kind === "timeout") {
+      log?.(`adb[${serial}] ${cmd} timed out after ${timeoutMs}ms; restarting shell`);
+      l.dead = true;
+      if (live === l)
+        live = undefined;
+      l.proc.kill();
+      return driverErr("E_TIMEOUT", `\`${cmd}\` did not finish within ${timeoutMs}ms on ${serial}`);
+    }
+    return driverErr("E_HELPER_CRASHED", `adb shell for ${serial} died while running \`${cmd}\``, {
+      detail: { tail: outcome.tail }
+    });
+  }
+  return {
+    run(cmd, opts) {
+      const next = tail.then(() => execute(cmd, opts?.timeoutMs ?? DEFAULT_ADB_TIMEOUT_MS));
+      tail = next.catch(() => {
+        return;
+      });
+      return next;
+    },
+    async close() {
+      closed = true;
+      const l = live;
+      live = undefined;
+      if (!l)
+        return;
+      l.dead = true;
+      l.proc.kill();
+      if (current) {
+        const settle = current.settle;
+        current = undefined;
+        settle({ kind: "crashed", tail: "" });
+      }
+      await l.proc.exited.catch(() => 0);
+    }
+  };
+}
+
+// ../../packages/e2e/src/alert-buttons.ts
+var ACCEPT_BUTTONS = [
+  "OK",
+  "Allow",
+  "Open",
+  "Continue",
+  "Yes",
+  "Done",
+  "Allow While Using App",
+  "Allow Once",
+  "While using the app",
+  "Only this time"
+];
+var DISMISS_BUTTONS = ["Cancel", "Don't Allow", "Not Now", "Dismiss", "No", "Close"];
+function normalise(text) {
+  return text.replace(/[\u2018\u2019]/g, "'").trim().toLowerCase();
+}
+function nameOf(button) {
+  return button.label ?? button.text ?? button.value;
+}
+function findButton(buttons, wanted) {
+  const target = normalise(wanted);
+  return buttons.find((button) => {
+    const name = nameOf(button);
+    return name !== undefined && normalise(name) === target;
+  });
+}
+function firstOf(buttons, names) {
+  for (const name of names) {
+    const found = findButton(buttons, name);
+    if (found !== undefined)
+      return found;
+  }
+  return;
+}
+function centre(element) {
+  const { x, y, width, height } = element.frame;
+  return element.tapPoint ?? { x: x + width / 2, y: y + height / 2 };
+}
+var ANDROID_PERMISSION_ALLOW_IDS = [
+  "permission_allow_button",
+  "permission_allow_foreground_only_button",
+  "permission_allow_one_time_button"
+];
+var ANDROID_PERMISSION_DENY_IDS = [
+  "permission_deny_button",
+  "permission_deny_and_dont_ask_again_button"
+];
+var ANDROID_POSITIVE_ID = "button1";
+var ANDROID_NEGATIVE_ID = "button2";
+var ANDROID_ALLOW_IDS = [...ANDROID_PERMISSION_ALLOW_IDS, ANDROID_POSITIVE_ID];
+var ANDROID_DENY_IDS = [...ANDROID_PERMISSION_DENY_IDS, ANDROID_NEGATIVE_ID];
+
+// ../../packages/e2e/src/driver/android/android-alert.ts
+var ALERT_BUTTON_IDS = new Set([
+  "button1",
+  "button2",
+  "button3",
+  "permission_allow_button",
+  "permission_allow_foreground_only_button",
+  "permission_allow_one_time_button",
+  "permission_deny_button",
+  "permission_deny_and_dont_ask_again_button",
+  "permission_no_upgrade_button",
+  "aerr_close",
+  "aerr_wait"
+]);
+function textOf(element) {
+  return element?.text || element?.label || undefined;
+}
+var byIdentifier = (flat, id) => flat.find((e) => e.identifier === id);
+function detectAlert(flat) {
+  const buttons = flat.filter((e) => e.identifier !== undefined && ALERT_BUTTON_IDS.has(e.identifier));
+  if (buttons.length === 0)
+    return null;
+  const title = textOf(byIdentifier(flat, "alertTitle")) ?? textOf(byIdentifier(flat, "permission_message"));
+  const message = textOf(byIdentifier(flat, "message"));
+  return { ...title ? { title } : {}, ...message ? { message } : {}, buttons };
+}
+
+// ../../packages/e2e/src/driver/android/android-argv.ts
+var SAFE_WORD = /^[A-Za-z0-9_@%+=:,./-]+$/;
+function shellQuote(word) {
+  if (word === "")
+    return "''";
+  if (SAFE_WORD.test(word))
+    return word;
+  return `'${word.replace(/'/g, "'\\''")}'`;
+}
+function shellCommand(argv) {
+  return argv.map(shellQuote).join(" ");
+}
+var px = (value) => String(Math.round(value));
+function tapArgv(point) {
+  return ["input", "tap", px(point.x), px(point.y)];
+}
+var DEFAULT_SWIPE_MS = 300;
+var DEFAULT_LONG_PRESS_MS = 600;
+function swipeArgv(from, to, durationMs = DEFAULT_SWIPE_MS) {
+  return ["input", "swipe", px(from.x), px(from.y), px(to.x), px(to.y), String(Math.max(1, Math.round(durationMs)))];
+}
+function motionEventArgv(action, point) {
+  return ["input", "motionevent", action, px(point.x), px(point.y)];
+}
+var MOTIONEVENT_MIN_SDK = 26;
+var SELECT_ALL_MIN_SDK = 33;
+var DRAG_STEPS = 8;
+function sleepArgv(ms) {
+  return ["sleep", (Math.max(0, ms) / 1000).toFixed(3)];
+}
+function dragMotionCommand(from, to, timing) {
+  const steps = Math.max(1, timing.steps ?? DRAG_STEPS);
+  const parts = [motionEventArgv("DOWN", from), sleepArgv(timing.pressMs)];
+  for (let i = 1;i <= steps; i++) {
+    const t = i / steps;
+    parts.push(motionEventArgv("MOVE", { x: from.x + (to.x - from.x) * t, y: from.y + (to.y - from.y) * t }), sleepArgv(timing.durationMs / steps));
+  }
+  parts.push(sleepArgv(timing.releaseMs), motionEventArgv("UP", to));
+  const cancel = shellCommand(motionEventArgv("CANCEL", to));
+  return `${parts.map((argv) => shellCommand(argv)).join(" && ")} || (${cancel}; exit 1)`;
+}
+var GESTURE_LINE_MAX_MOVES = 12;
+function gestureMotionCommand(plan, maxMoves = GESTURE_LINE_MAX_MOVES) {
+  const path = plan.paths[0] ?? [];
+  const first = path[0] ?? { x: 0, y: 0 };
+  const last = path.at(-1) ?? first;
+  const intervals = path.length - 1;
+  const count = Math.min(Math.max(1, Math.floor(maxMoves)), Math.max(0, intervals));
+  const travelMs = Math.max(0, intervals) * plan.frameMs;
+  const parts = [motionEventArgv("DOWN", first), sleepArgv(plan.holdMs)];
+  for (let k = 1;k <= count; k++) {
+    const at = path[Math.round(k * intervals / count)] ?? last;
+    parts.push(sleepArgv(travelMs / count), motionEventArgv("MOVE", at));
+  }
+  parts.push(sleepArgv(plan.releaseMs), motionEventArgv("UP", last));
+  const cancel = shellCommand(motionEventArgv("CANCEL", last));
+  return `${parts.map((argv) => shellCommand(argv)).join(" && ")} || (${cancel}; exit 1)`;
+}
+function longPressArgv(point, durationMs = DEFAULT_LONG_PRESS_MS) {
+  return swipeArgv(point, point, durationMs);
+}
+function keyeventArgv(keycode) {
+  return ["input", "keyevent", String(keycode)];
+}
+var KEYEVENT_CHUNK = 32;
+function keyRepeatArgvs(keycode, times) {
+  const argvs = [];
+  for (let left = Math.max(0, Math.floor(times));left > 0; left -= KEYEVENT_CHUNK) {
+    argvs.push(["input", "keyevent", ...Array(Math.min(left, KEYEVENT_CHUNK)).fill(String(keycode))]);
+  }
+  return argvs;
+}
+function buttonKeycode(button) {
+  switch (button) {
+    case "home":
+      return 3;
+    case "back":
+      return 4;
+    case "volumeUp":
+      return 24;
+    case "volumeDown":
+      return 25;
+    case "lock":
+      return 26;
+    case "shake":
+      return;
+  }
+}
+function keyNameKeycode(key) {
+  switch (key) {
+    case "Enter":
+      return 66;
+    case "Backspace":
+      return 67;
+    case "Tab":
+      return 61;
+    case "Space":
+      return 62;
+    case "Escape":
+      return 111;
+    case "Delete":
+      return 112;
+    case "Up":
+      return 19;
+    case "Down":
+      return 20;
+    case "Left":
+      return 21;
+    case "Right":
+      return 22;
+  }
+}
+function splitForInputText(text) {
+  const pieces = [];
+  let current = "";
+  for (let i = 0;i < text.length; i++) {
+    const ch = text.charAt(i);
+    current += ch;
+    const next = text.charAt(i + 1);
+    if (ch === "%" && (next === " " || next === "s")) {
+      pieces.push(current);
+      current = "";
+    }
+  }
+  if (current !== "")
+    pieces.push(current);
+  return pieces;
+}
+function textArgvs(text) {
+  for (const ch of text) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code < 32 || code > 126) {
+      return driverErr("E_UNSUPPORTED_TEXT", `Android \`input text\` only types printable ASCII; got U+${code.toString(16).toUpperCase().padStart(4, "0")}`);
+    }
+  }
+  return { success: true, data: splitForInputText(text).map((piece) => ["input", "text", piece.replace(/ /g, "%s")]) };
+}
+function startUrlArgv(url, packageName) {
+  const argv = ["am", "start", "-a", "android.intent.action.VIEW", "-d", url];
+  return packageName === undefined ? argv : [...argv, "-p", packageName];
+}
+function monkeyLaunchArgv(packageName) {
+  return ["monkey", "-p", packageName, "-c", "android.intent.category.LAUNCHER", "1"];
+}
+function resolveLauncherArgv(packageName) {
+  return ["cmd", "package", "resolve-activity", "--brief", "-c", "android.intent.category.LAUNCHER", packageName];
+}
+function startComponentArgv(component, options) {
+  return [
+    "am",
+    "start",
+    "-W",
+    ...options.stop ? ["-S"] : [],
+    "-a",
+    "android.intent.action.MAIN",
+    "-c",
+    "android.intent.category.LAUNCHER",
+    "-n",
+    component
+  ];
+}
+function forceStopArgv(packageName) {
+  return ["am", "force-stop", packageName];
+}
+function pmClearArgv(packageName) {
+  return ["pm", "clear", packageName];
+}
+var ANIMATION_SETTINGS = [
+  "window_animation_scale",
+  "transition_animation_scale",
+  "animator_duration_scale"
+];
+function animationScaleArgvs() {
+  return ANIMATION_SETTINGS.map((key) => ["settings", "put", "global", key, "0"]);
+}
+function animationReadArgvs() {
+  return ANIMATION_SETTINGS.map((key) => ["settings", "get", "global", key]);
+}
+function animationRestoreArgvs(values) {
+  return ANIMATION_SETTINGS.map((key) => values[key] === "null" ? ["settings", "delete", "global", key] : ["settings", "put", "global", key, values[key]]);
+}
+function screencapArgv(adb, serial) {
+  return [adb, "-s", serial, "exec-out", "screencap", "-p"];
+}
+function getpropArgv(key) {
+  return ["getprop", key];
+}
+var WM_SIZE_ARGV = ["wm", "size"];
+var WM_DENSITY_ARGV = ["wm", "density"];
+var DUMP_FILE_PATH = "/sdcard/warden-ui.xml";
+function dumpStdoutArgv() {
+  return ["uiautomator", "dump", "/dev/stdout"];
+}
+function dumpTtyHostArgv(adb, serial) {
+  return [adb, "-s", serial, "exec-out", "uiautomator", "dump", "/dev/tty"];
+}
+function dumpFileCommand(path = DUMP_FILE_PATH) {
+  const file = shellQuote(path);
+  return `rm -f ${file}; OUT=$(uiautomator dump ${file} 2>&1); cat ${file} 2>/dev/null || echo "$OUT"`;
+}
+function installArgv(adb, serial, apkPath) {
+  return [adb, "-s", serial, "install", "-r", apkPath];
+}
+function uninstallArgv(adb, serial, packageName) {
+  return [adb, "-s", serial, "uninstall", packageName];
+}
+function pmPathArgv(packageName) {
+  return ["pm", "path", packageName];
+}
+function pidofArgv(packageName) {
+  return ["pidof", packageName];
+}
+function rotationArgvs(rotation) {
+  return [
+    ["settings", "put", "system", "accelerometer_rotation", "0"],
+    ["settings", "put", "system", "user_rotation", String(rotation)]
+  ];
+}
+function userRotationArgv() {
+  return ["settings", "get", "system", "user_rotation"];
+}
+function uimodeGetArgv() {
+  return ["cmd", "uimode", "night"];
+}
+function uimodeSetArgv(dark) {
+  return ["cmd", "uimode", "night", dark ? "yes" : "no"];
+}
+function keycombinationArgv(keycodes) {
+  return ["input", "keycombination", ...keycodes.map(String)];
+}
+var KEYCODE_A = 29;
+function selectAllArgv() {
+  return keycombinationArgv([modifierKeycode("ctrl"), KEYCODE_A]);
+}
+function modifierKeycode(modifier) {
+  switch (modifier) {
+    case "shift":
+      return 59;
+    case "cmd":
+      return 117;
+    case "alt":
+      return 57;
+    case "ctrl":
+      return 113;
+  }
+}
+
+// ../../packages/e2e/src/driver/android/android-state.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+import { z } from "zod";
+var scaleValue = z.string().regex(/^(null|\d+(\.\d+)?)$/);
+var stateSchema = z.strictObject({
+  sdk: z.number().int().optional(),
+  dumpRoute: z.enum(["stdout", "tty", "file"]).optional(),
+  uiadUnsupported: z.string().regex(/^[0-9a-f]{1,16}$/).optional(),
+  animations: z.strictObject({
+    window_animation_scale: scaleValue,
+    transition_animation_scale: scaleValue,
+    animator_duration_scale: scaleValue
+  }).optional()
+});
+var nodeStateFs = {
+  readFile: (path) => readFile(path, "utf8"),
+  writeFile: (path, data) => writeFile(path, data),
+  rename,
+  mkdir: async (path) => {
+    await mkdir(path, { recursive: true });
+  }
+};
+function androidStateDir(home = wardenHome(process.env)) {
+  return join3(home, "android");
+}
+function androidStateFile(dir, serial) {
+  return join3(dir, `${serial.replace(/[^A-Za-z0-9._:-]/g, "_")}.json`);
+}
+function createAndroidStateStore(options) {
+  const { dir, log } = options;
+  const fs = options.fs ?? nodeStateFs;
+  let queue = Promise.resolve();
+  async function load(serial) {
+    let text;
+    try {
+      text = await fs.readFile(androidStateFile(dir, serial));
+    } catch {
+      return {};
+    }
+    try {
+      const parsed = stateSchema.safeParse(JSON.parse(text));
+      return parsed.success ? stripUndefined(parsed.data) : {};
+    } catch {
+      return {};
+    }
+  }
+  async function save(serial, change) {
+    const before = await load(serial);
+    const after = stripUndefined(change(before));
+    const text = JSON.stringify(after);
+    if (text === JSON.stringify(before))
+      return;
+    const file = androidStateFile(dir, serial);
+    try {
+      await fs.mkdir(dir);
+      const temp = `${file}.${process.pid}.tmp`;
+      await fs.writeFile(temp, text);
+      await fs.rename(temp, file);
+    } catch (error) {
+      log?.(`could not save ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return {
+    read: load,
+    update(serial, change) {
+      const run = queue.then(() => save(serial, change));
+      queue = run.catch(() => {
+        return;
+      });
+      return run.catch(() => {
+        return;
+      });
+    }
+  };
+}
+function forSdk(state, sdk) {
+  return state.sdk === sdk ? state : {};
+}
+function patchFor(sdk, patch) {
+  return (state) => ({ ...forSdk(state, sdk), ...sdk !== undefined ? { sdk } : {}, ...patch });
+}
+function stripUndefined(state) {
+  return {
+    ...state.sdk !== undefined ? { sdk: state.sdk } : {},
+    ...state.dumpRoute !== undefined ? { dumpRoute: state.dumpRoute } : {},
+    ...state.uiadUnsupported !== undefined ? { uiadUnsupported: state.uiadUnsupported } : {},
+    ...state.animations !== undefined ? { animations: state.animations } : {}
+  };
+}
+var SCALE_LINE = /^(null|\d+(\.\d+)?)$/;
+function parseAnimationValues(stdout) {
+  const lines = stdout.split(`
+`).map((line) => line.trim()).filter((line) => SCALE_LINE.test(line));
+  const [window, transition, animator] = lines;
+  if (lines.length !== ANIMATION_SETTINGS.length || window === undefined || transition === undefined || animator === undefined) {
+    return;
+  }
+  return { window_animation_scale: window, transition_animation_scale: transition, animator_duration_scale: animator };
+}
+function planAnimations(current, pending) {
+  const original = (key) => current[key] === "0" && pending ? pending[key] : current[key];
+  const originals = {
+    window_animation_scale: original("window_animation_scale"),
+    transition_animation_scale: original("transition_animation_scale"),
+    animator_duration_scale: original("animator_duration_scale")
+  };
+  return ANIMATION_SETTINGS.every((key) => originals[key] === "0") ? undefined : originals;
+}
+
+// ../../packages/e2e/src/driver/android/android-animations.ts
+var sameValues = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+async function disableAnimations(deps) {
+  const { session, serial, sdk, state, log } = deps;
+  const command = [...animationReadArgvs(), ...animationScaleArgvs()].map((argv) => shellCommand(argv)).join("; ");
+  let restorable = deps.pending;
+  const ran = await session.run(command);
+  if (!ran.success || ran.data.exitCode !== 0) {
+    log?.("could not disable animations");
+  } else {
+    const found = parseAnimationValues(ran.data.stdout);
+    if (found === undefined)
+      log?.("could not read the animation scales, so they will not be restored");
+    else
+      restorable = planAnimations(found, deps.pending);
+  }
+  if (state && !sameValues(restorable, deps.pending)) {
+    await state.update(serial, patchFor(sdk, { animations: restorable }));
+  }
+  return {
+    async restore() {
+      const originals = restorable;
+      if (originals === undefined)
+        return;
+      restorable = undefined;
+      const put = await session.run(animationRestoreArgvs(originals).map((argv) => shellCommand(argv)).join("; "));
+      if (!put.success || put.data.exitCode !== 0) {
+        log?.("could not restore the animation scales; the next driver on this device will");
+        return;
+      }
+      await state?.update(serial, patchFor(sdk, { animations: undefined }));
+    }
+  };
+}
+
+// ../../packages/e2e/src/driver/android/android-device.ts
+var BOOT_TIMEOUT_MS = 30000;
+var BOOT_POLL_MS = 500;
+var realClock = { now: () => Date.now(), sleep: (ms) => Bun.sleep(ms) };
+function parseWmSize(text) {
+  const override = /Override size:\s*(\d+)x(\d+)/.exec(text);
+  const physical = /Physical size:\s*(\d+)x(\d+)/.exec(text);
+  const m = override ?? physical;
+  if (!m)
+    return;
+  return { width: Number(m[1]), height: Number(m[2]) };
+}
+function parseWmDensity(text) {
+  const m = /Override density:\s*(\d+)/.exec(text) ?? /Physical density:\s*(\d+)/.exec(text);
+  return m ? Number(m[1]) / 160 : undefined;
+}
+var isFatal = (error) => error.code === "E_HELPER_MISSING" || error.code === "E_INTERNAL";
+var BOOT_PROBE = [
+  getpropArgv("sys.boot_completed"),
+  getpropArgv("ro.build.version.sdk"),
+  WM_SIZE_ARGV,
+  WM_DENSITY_ARGV
+].map((argv) => shellCommand(argv)).join("; ");
+function sdkFromProbe(stdout) {
+  const line = stdout.trimStart().split(`
+`)[1]?.trim() ?? "";
+  return /^\d+$/.test(line) ? Number(line) : undefined;
+}
+function screenFromProbe(stdout) {
+  const size = parseWmSize(stdout);
+  if (!size)
+    return;
+  return { ...size, scale: parseWmDensity(stdout) ?? 1, rotation: 0 };
+}
+async function waitForBoot(session, serial, clock, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? BOOT_TIMEOUT_MS;
+  const deadline = clock.now() + timeoutMs;
+  for (;; ) {
+    const res = await session.run(BOOT_PROBE, { timeoutMs: 5000 });
+    if (res.success && res.data.stdout.trimStart().startsWith("1")) {
+      return { success: true, data: { screen: screenFromProbe(res.data.stdout), sdk: sdkFromProbe(res.data.stdout) } };
+    }
+    if (!res.success && isFatal(res.error))
+      return res;
+    if (clock.now() >= deadline) {
+      return driverErr("E_NOT_BOOTED", `${serial} did not report sys.boot_completed=1 within ${timeoutMs}ms`, {
+        detail: res.success ? { stdout: res.data.stdout } : { error: res.error }
+      });
+    }
+    opts.log?.(`waiting for ${serial} to boot`);
+    await clock.sleep(BOOT_POLL_MS);
+  }
+}
+async function readScreen(session, serial) {
+  const size = await session.run(shellCommand(WM_SIZE_ARGV));
+  if (!size.success)
+    return size;
+  const parsed = parseWmSize(size.data.stdout);
+  if (!parsed) {
+    return driverErr("E_INTERNAL", `cannot parse \`wm size\` for ${serial}: ${size.data.stdout.trim().slice(0, 120)}`);
+  }
+  const density = await session.run(shellCommand(WM_DENSITY_ARGV));
+  const scale = (density.success ? parseWmDensity(density.data.stdout) : undefined) ?? 1;
+  return { success: true, data: { ...parsed, scale, rotation: 0 } };
+}
+function hierarchyRotation(xml) {
+  const m = /<hierarchy[^>]*\brotation="(\d)"/.exec(xml);
+  return m ? Number(m[1]) : 0;
+}
+function rotatedScreen(base, rotation) {
+  const landscape = rotation % 2 === 1;
+  const portraitW = Math.min(base.width, base.height);
+  const portraitH = Math.max(base.width, base.height);
+  return {
+    ...base,
+    width: landscape ? portraitH : portraitW,
+    height: landscape ? portraitW : portraitH,
+    rotation
+  };
+}
+function rotationToOrientation(rotation) {
+  switch (rotation) {
+    case 1:
+      return "landscapeLeft";
+    case 2:
+      return "portraitUpsideDown";
+    case 3:
+      return "landscapeRight";
+    default:
+      return "portrait";
+  }
+}
+function orientationToRotation(orientation) {
+  switch (orientation) {
+    case "landscapeLeft":
+      return 1;
+    case "portraitUpsideDown":
+      return 2;
+    case "landscapeRight":
+      return 3;
+    case "portrait":
+      return 0;
+  }
+}
+async function runChecked(session, cmd, failure = "E_HID", timeoutMs) {
+  const res = await session.run(cmd, timeoutMs === undefined ? undefined : { timeoutMs });
+  if (!res.success)
+    return res;
+  if (res.data.exitCode !== 0) {
+    return driverErr(failure, `\`${cmd}\` exited ${res.data.exitCode}: ${res.data.stdout.trim().slice(0, 200)}`);
+  }
+  return { success: true, data: res.data.stdout };
+}
+
+// ../../packages/e2e/src/driver/android/android-app.ts
+var ok2 = { success: true, data: undefined };
+var NO_ACTIVITY = /No activities found|monkey aborted|Error type 3|does not exist|Unknown package/i;
+var START_WAIT_TIMEOUT_MS = 30000;
+var START_PROBE_TIMEOUT_MS = 5000;
+var COMPONENT = /^[A-Za-z0-9_.]+\/[A-Za-z0-9_.$]+$/;
+function parseLauncherComponent(stdout) {
+  const last = stdout.split(`
+`).map((line) => line.trim()).filter((line) => line !== "").at(-1);
+  return last !== undefined && COMPONENT.test(last) ? last : undefined;
+}
+function parseStartWait(stdout) {
+  const field = (name) => new RegExp(`^${name}: *(.+)$`, "m").exec(stdout)?.[1]?.trim();
+  const parsed = {};
+  const status = field("Status");
+  const launchState = field("LaunchState");
+  const totalTime = Number(field("TotalTime"));
+  const error = /^Error: *(.+)$/m.exec(stdout)?.[1]?.trim();
+  if (status !== undefined)
+    parsed.status = status;
+  if (launchState !== undefined)
+    parsed.launchState = launchState;
+  if (Number.isFinite(totalTime) && field("TotalTime") !== undefined)
+    parsed.totalTimeMs = totalTime;
+  if (error !== undefined)
+    parsed.error = error;
+  return parsed;
+}
+function noteStarted(started) {
+  noteSpanDetail("launch", "am-start");
+  if (started.status !== undefined)
+    noteSpanDetail("startStatus", started.status);
+  if (started.launchState !== undefined)
+    noteSpanDetail("launchState", started.launchState);
+  if (started.totalTimeMs !== undefined)
+    noteSpanDetail("totalTimeMs", started.totalTimeMs);
+}
+function createAppCommands(deps) {
+  const { session, exec, adb, serial } = deps;
+  const launchers = new Map;
+  const launcherOf = async (bundleId) => {
+    const known = launchers.get(bundleId);
+    if (known !== undefined)
+      return known;
+    const res = await session.run(shellCommand(resolveLauncherArgv(bundleId)));
+    if (!res.success || res.data.exitCode !== 0)
+      return;
+    const component = parseLauncherComponent(res.data.stdout);
+    if (component !== undefined)
+      launchers.set(bundleId, component);
+    return component;
+  };
+  const hasProcess = async (bundleId) => {
+    const probe = await session.run(shellCommand(pidofArgv(bundleId)), {
+      timeoutMs: deps.startProbeTimeoutMs ?? START_PROBE_TIMEOUT_MS
+    });
+    return probe.success && probe.data.exitCode === 0 && /\d/.test(probe.data.stdout);
+  };
+  const startWaiting = async (bundleId, relaunch) => {
+    const component = await launcherOf(bundleId);
+    if (component === undefined)
+      return { success: true, data: false };
+    const res = await session.run(shellCommand(startComponentArgv(component, { stop: relaunch })), {
+      timeoutMs: deps.startWaitTimeoutMs ?? START_WAIT_TIMEOUT_MS
+    });
+    if (!res.success && res.error.code === "E_TIMEOUT") {
+      if (!await hasProcess(bundleId))
+        return res;
+      noteStarted({ launchState: "timeout" });
+      return { success: true, data: true };
+    }
+    if (!res.success)
+      return res;
+    const started = parseStartWait(res.data.stdout);
+    if (res.data.exitCode !== 0 || started.error !== undefined) {
+      launchers.delete(bundleId);
+      return { success: true, data: false };
+    }
+    noteStarted(started);
+    return { success: true, data: true };
+  };
+  async function hostAdb(argv) {
+    try {
+      const res = await exec(argv, { timeoutMs: 120000 });
+      return { ok: res.exitCode === 0, text: `${res.stdout}
+${res.stderr}`.trim() };
+    } catch (error) {
+      return { ok: false, text: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  const terminate = async (bundleId) => {
+    const res = await runChecked(session, shellCommand(forceStopArgv(bundleId)), "E_APP_UNAVAILABLE");
+    return res.success ? ok2 : res;
+  };
+  const isInstalled = async (bundleId) => {
+    const res = await session.run(shellCommand(pmPathArgv(bundleId)));
+    if (!res.success)
+      return res;
+    return { success: true, data: res.data.exitCode === 0 && res.data.stdout.includes("package:") };
+  };
+  const isRunning = async (bundleId) => {
+    const res = await session.run(shellCommand(pidofArgv(bundleId)));
+    if (!res.success)
+      return res;
+    return { success: true, data: res.data.exitCode === 0 && /\d/.test(res.data.stdout) };
+  };
+  const monkeyLaunch = async (bundleId, relaunch) => {
+    if (relaunch) {
+      const stopped = await terminate(bundleId);
+      if (!stopped.success)
+        return stopped;
+    }
+    noteSpanDetail("launch", "monkey");
+    const res = await session.run(shellCommand(monkeyLaunchArgv(bundleId)));
+    if (!res.success)
+      return res;
+    if (res.data.exitCode !== 0 || NO_ACTIVITY.test(res.data.stdout)) {
+      return driverErr("E_APP_UNAVAILABLE", `cannot launch ${bundleId}: ${res.data.stdout.trim().slice(0, 200)}`);
+    }
+    return ok2;
+  };
+  const launch = async (bundleId, opts) => {
+    if ((opts?.args?.length ?? 0) > 0 || Object.keys(opts?.env ?? {}).length > 0) {
+      return driverErr("E_UNSUPPORTED", "Android launch does not support args/env in v1 (use openUrl with a deep link for dev-client Metro urls)");
+    }
+    const relaunch = opts?.relaunch !== false;
+    const waited = await startWaiting(bundleId, relaunch);
+    if (!waited.success)
+      return waited;
+    return waited.data ? ok2 : monkeyLaunch(bundleId, relaunch);
+  };
+  const openUrl = async (url) => {
+    const res = await session.run(shellCommand(startUrlArgv(url, deps.appPackage)));
+    if (!res.success)
+      return res;
+    if (res.data.exitCode !== 0 || /^Error:|Exception/m.test(res.data.stdout)) {
+      return driverErr("E_APP_UNAVAILABLE", `no activity handles ${url}: ${res.data.stdout.trim().slice(0, 200)}`);
+    }
+    return ok2;
+  };
+  const install = async (path) => {
+    launchers.clear();
+    const res = await hostAdb(installArgv(adb, serial, path));
+    return res.ok && res.text.includes("Success") ? ok2 : driverErr("E_IO", `adb install failed: ${res.text.slice(-200)}`);
+  };
+  const uninstall = async (bundleId) => {
+    launchers.delete(bundleId);
+    const installed = await isInstalled(bundleId);
+    if (!installed.success)
+      return installed;
+    if (!installed.data)
+      return ok2;
+    const res = await hostAdb(uninstallArgv(adb, serial, bundleId));
+    return res.ok && res.text.includes("Success") ? ok2 : driverErr("E_IO", `adb uninstall failed: ${res.text.slice(-200)}`);
+  };
+  const clearData = async (bundleId) => {
+    const res = await runChecked(session, shellCommand(pmClearArgv(bundleId)), "E_APP_UNAVAILABLE");
+    if (!res.success)
+      return res;
+    return res.data.includes("Success") ? ok2 : driverErr("E_APP_UNAVAILABLE", `pm clear ${bundleId}: ${res.data.trim()}`);
+  };
+  return { launch, terminate, openUrl, install, uninstall, isInstalled, isRunning, clearData };
+}
+
+// ../../packages/e2e/src/driver/android/android-dump.ts
+var DUMP_ROUTES = ["stdout", "tty", "file"];
+var TTY_FIRST_SDK = 30;
+function routeOrder(sdk, known) {
+  const guess = sdk !== undefined && sdk >= TTY_FIRST_SDK ? ["tty", "stdout", "file"] : DUMP_ROUTES;
+  return known ? [known, ...guess.filter((r) => r !== known)] : [...guess];
+}
+var DUMP_TIMEOUT_MS = 20000;
+function createDumper(deps) {
+  let known = deps.initialRoute;
+  async function fetchRoute(route) {
+    if (route === "tty") {
+      try {
+        const res = await deps.exec(dumpTtyHostArgv(deps.adb, deps.serial), { timeoutMs: DUMP_TIMEOUT_MS });
+        return { text: res.stdout };
+      } catch (error) {
+        return { error: { code: "E_IO", message: String(error), retryable: false } };
+      }
+    }
+    const cmd = route === "stdout" ? shellCommand(dumpStdoutArgv()) : dumpFileCommand();
+    const res = await deps.session.run(cmd, { timeoutMs: DUMP_TIMEOUT_MS });
+    return res.success ? { text: res.data.stdout } : { error: res.error };
+  }
+  async function tryRoutes(order) {
+    const failure = {};
+    for (const route of order) {
+      const fetchStarted = Date.now();
+      const result = await fetchRoute(route);
+      addSpanDetail("dumpMs", Date.now() - fetchStarted);
+      addSpanDetail("dumpRoutesTried", 1);
+      if ("error" in result) {
+        failure.error = result.error;
+        deps.log?.(`uiautomator dump via ${route} failed: ${result.error.code}`);
+      } else if (result.text.includes("<hierarchy")) {
+        return { xml: result.text, route };
+      } else {
+        failure.output = result.text;
+        deps.log?.(`uiautomator dump via ${route} returned no hierarchy`);
+      }
+    }
+    return failure;
+  }
+  return {
+    route: () => known,
+    async dump() {
+      const found = await tryRoutes(routeOrder(deps.sdk, known));
+      if ("xml" in found) {
+        noteSpanDetail("dumpRoute", found.route);
+        if (known !== found.route)
+          deps.log?.(`uiautomator dump route: ${found.route}`);
+        if (known !== found.route)
+          deps.onRoute?.(found.route);
+        known = found.route;
+        return { success: true, data: found };
+      }
+      if (found.output === undefined && found.error)
+        return { success: false, error: found.error };
+      const output = found.output ?? "";
+      return driverErr("E_AX_UNAVAILABLE", `uiautomator produced no hierarchy: ${output.trim().slice(0, 160)}`, {
+        detail: { output: output.slice(0, 400) }
+      });
+    }
+  };
+}
+
+// ../../packages/e2e/src/driver/android/uiad-protocol.ts
+import { z as z2 } from "zod";
+var UIAD_PROTOCOL = 1;
+var UIAD_MAIN_CLASS = "nz.co.delacour.warden.uiad.Main";
+var STRING_FIELDS = ["class", "pkg", "id", "text", "desc", "hint"];
+var FLAG_FIELDS = [
+  "clickable",
+  "longClickable",
+  "checkable",
+  "checked",
+  "scrollable",
+  "selected",
+  "focused",
+  "focusable",
+  "password",
+  "editable",
+  "disabled",
+  "invisible"
+];
+function isBounds(value) {
+  return Array.isArray(value) && value.length === 4 && value.every((n) => typeof n === "number");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function copyFields(node, from, keys, kind, path) {
+  for (const key of keys) {
+    const field = from[key];
+    if (field === undefined)
+      continue;
+    if (typeof field !== kind)
+      return `${path}.${key}: not a ${kind}`;
+    Object.assign(node, { [key]: field });
+  }
+  return;
+}
+function readNode(value, path = "elements") {
+  if (!isRecord(value))
+    return `${path}: not an object`;
+  if (!isBounds(value.bounds))
+    return `${path}.bounds: not [l, t, r, b]`;
+  const node = { bounds: value.bounds };
+  const wrong = copyFields(node, value, STRING_FIELDS, "string", path) ?? copyFields(node, value, FLAG_FIELDS, "boolean", path) ?? copyFields(node, value, ["order"], "number", path);
+  if (wrong !== undefined)
+    return wrong;
+  if (value.children === undefined)
+    return node;
+  if (!Array.isArray(value.children))
+    return `${path}.children: not an array`;
+  const children = [];
+  for (const [index, child] of value.children.entries()) {
+    const read = readNode(child, `${path}.children[${index}]`);
+    if (typeof read === "string")
+      return read;
+    children.push(read);
+  }
+  node.children = children;
+  return node;
+}
+var screenSchema = z2.object({
+  width: z2.number(),
+  height: z2.number(),
+  scale: z2.number().optional(),
+  rotation: z2.number().optional()
+});
+var healthSchema = z2.looseObject({
+  version: z2.string(),
+  protocol: z2.number(),
+  sdk: z2.number(),
+  release: z2.string().optional(),
+  model: z2.string().optional(),
+  uid: z2.number().optional(),
+  pid: z2.number().optional(),
+  uiAutomation: z2.looseObject({ state: z2.string(), connect: z2.string().optional(), connectMs: z2.number().optional() }),
+  events: z2.looseObject({ count: z2.number(), lastAgoMs: z2.number() }).optional(),
+  uptimeMs: z2.number().optional(),
+  screen: screenSchema.optional(),
+  displayError: z2.string().optional()
+});
+var settleDataSchema = z2.looseObject({
+  quiet: z2.boolean(),
+  waitedMs: z2.number(),
+  via: z2.literal("events"),
+  events: z2.number(),
+  firstEventMs: z2.number().optional(),
+  reason: z2.string().optional()
+});
+var textDataSchema = z2.looseObject({
+  text: z2.string(),
+  caret: z2.number().optional(),
+  caretPlaced: z2.boolean().optional()
+});
+var snapshotEnvelope = z2.looseObject({
+  backend: z2.literal("uiad"),
+  screen: screenSchema,
+  windows: z2.array(z2.unknown()).optional(),
+  elements: z2.array(z2.unknown()),
+  truncated: z2.boolean(),
+  nodes: z2.number(),
+  readMs: z2.number(),
+  ms: z2.number()
+});
+function readSnapshotData(data) {
+  const envelope = snapshotEnvelope.safeParse(data);
+  if (!envelope.success) {
+    const issue = envelope.error.issues[0];
+    return issue ? `${issue.path.join(".") || "(snapshot)"}: ${issue.message}` : "invalid snapshot";
+  }
+  const elements = [];
+  for (const [index, raw] of envelope.data.elements.entries()) {
+    const node = readNode(raw, `elements[${index}]`);
+    if (typeof node === "string")
+      return node;
+    elements.push(node);
+  }
+  return { ...envelope.data, elements };
+}
+var readyEventSchema = z2.object({
+  event: z2.literal("ready"),
+  protocol: z2.number(),
+  version: z2.string(),
+  data: healthSchema
+});
+var eventSchema = z2.discriminatedUnion("event", [readyEventSchema, logEventSchema, fatalEventSchema]);
+function parseUiadLine(line) {
+  let json;
+  try {
+    json = JSON.parse(line);
+  } catch {
+    return { success: false, reason: "not JSON" };
+  }
+  if (isRecord(json) && "event" in json) {
+    const event = eventSchema.safeParse(json);
+    return event.success ? { success: true, message: { kind: "event", event: event.data } } : { success: false, reason: `bad event: ${event.error.message}` };
+  }
+  const response = responseSchema.safeParse(json);
+  return response.success ? { success: true, message: { kind: "response", response: response.data } } : { success: false, reason: `bad response: ${response.error.message}` };
+}
+
+// ../../packages/e2e/src/driver/android/uiad-client.ts
+var DEFAULT_READY_TIMEOUT_MS2 = 5000;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var DEFAULT_GRACE_MS = 1000;
+var SHUTDOWN_WAIT_MS = 300;
+var NOT_SENT = { sent: false };
+function schemaReader(schema) {
+  return (data) => {
+    const parsed = schema.safeParse(data);
+    return parsed.success ? { ok: true, value: parsed.data } : { ok: false, reason: parsed.error.message };
+  };
+}
+var readSnapshot = (data) => {
+  const value = readSnapshotData(data);
+  return typeof value === "string" ? { ok: false, reason: value } : { ok: true, value };
+};
+function through(result, read, op) {
+  if (!result.success)
+    return result;
+  const checked = read(result.data);
+  return checked.ok ? { success: true, data: checked.value } : {
+    success: false,
+    error: driverError("E_INTERNAL", `warden-uiad \`${op}\` reply is malformed: ${checked.reason}`)
+  };
+}
+function exitMessage(info) {
+  const exit = info.exitCode === null ? "" : ` (exit ${info.exitCode})`;
+  const tail = info.stderrTail.length > 0 ? `: ${info.stderrTail.slice(-3).join(" | ")}` : "";
+  return `warden-uiad exited${exit}${tail}`;
+}
+async function startUiad(options) {
+  const { log } = options;
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS2;
+  const pending = new Map;
+  const deathHandlers = [];
+  let seq = 0;
+  let alive = true;
+  let closing = false;
+  let transport;
+  let settleHandshake = () => {
+    return;
+  };
+  let handshaken = false;
+  const failAll = (error) => {
+    for (const [id, entry] of pending) {
+      clearTimeout(entry.timer);
+      pending.delete(id);
+      entry.resolve({ success: false, error });
+    }
+  };
+  const onEvent = (event) => {
+    if (event.event === "log") {
+      log?.(`uiad ${event.level}: ${event.message}`);
+    } else if (event.event === "ready") {
+      settleHandshake(event.protocol === UIAD_PROTOCOL ? { success: true, data: event.data } : {
+        success: false,
+        error: driverError("E_UNSUPPORTED", `warden-uiad speaks protocol ${event.protocol}, this client speaks ${UIAD_PROTOCOL}`)
+      });
+    } else {
+      const error = mapWireError(event.error);
+      settleHandshake({ success: false, error });
+      failAll(error);
+    }
+  };
+  const onResponse = (response) => {
+    const entry = pending.get(response.id);
+    if (!entry) {
+      log?.(`uiad: reply to nothing (id ${response.id})`);
+      return;
+    }
+    clearTimeout(entry.timer);
+    pending.delete(response.id);
+    entry.resolve(response.ok ? { success: true, data: response.data } : { success: false, error: mapWireError(response.error) });
+  };
+  const onLine = (line) => {
+    const parsed = parseUiadLine(line);
+    if (!parsed.success) {
+      log?.(`uiad: ignoring a line (${parsed.reason}): ${line.slice(0, 120)}`);
+    } else if (parsed.message.kind === "event") {
+      onEvent(parsed.message.event);
+    } else {
+      onResponse(parsed.message.response);
+    }
+  };
+  const onClose = (info) => {
+    const wasAlive = alive;
+    alive = false;
+    const crash = driverError("E_HELPER_CRASHED", exitMessage(info), {
+      detail: { exitCode: info.exitCode, stderrTail: info.stderrTail }
+    });
+    settleHandshake({ success: false, error: crash });
+    failAll(crash);
+    if (wasAlive && !closing)
+      for (const handler of deathHandlers)
+        handler(info);
+  };
+  const factory = stdioTransport({
+    cmd: options.cmd,
+    ...options.spawn ? { spawn: options.spawn } : { spawn: bunSpawn },
+    graceMs: options.graceMs ?? DEFAULT_GRACE_MS
+  });
+  const waiting = new Promise((resolve) => {
+    settleHandshake = (result) => {
+      if (handshaken)
+        return;
+      handshaken = true;
+      resolve(result);
+    };
+  });
+  const opened = await factory({
+    onLine,
+    onDiagnostic: (line) => log?.(`uiad stderr: ${line}`),
+    onClose
+  });
+  if (!opened.success)
+    return opened;
+  transport = opened.data;
+  const timer = setTimeout(() => settleHandshake({
+    success: false,
+    error: driverError("E_TIMEOUT", `warden-uiad sent no ready event within ${readyTimeoutMs}ms`)
+  }), readyTimeoutMs);
+  const ready = await waiting;
+  clearTimeout(timer);
+  if (!ready.success) {
+    alive = false;
+    closing = true;
+    await transport.close().catch(() => {
+      return;
+    });
+    return ready;
+  }
+  const request = (op, params = {}, opts = {}) => new Promise((resolve) => {
+    if (!alive || transport === undefined) {
+      resolve({
+        success: false,
+        error: driverError("E_HELPER_CRASHED", "warden-uiad is not running", { detail: NOT_SENT })
+      });
+      return;
+    }
+    const id = String(++seq);
+    const timeoutMs = opts.timeoutMs ?? requestTimeoutMs;
+    const entry = {
+      op,
+      resolve,
+      timer: setTimeout(() => {
+        pending.delete(id);
+        const error = driverError("E_TIMEOUT", `warden-uiad did not answer \`${op}\` within ${timeoutMs}ms`);
+        resolve({ success: false, error });
+        alive = false;
+        failAll(error);
+        transport?.close().catch(() => {
+          return;
+        });
+      }, timeoutMs)
+    };
+    pending.set(id, entry);
+    try {
+      transport.send(encodeRequest({ ...params, id, op }));
+    } catch (error) {
+      clearTimeout(entry.timer);
+      pending.delete(id);
+      resolve({
+        success: false,
+        error: driverError("E_HELPER_CRASHED", `cannot write to warden-uiad: ${error instanceof Error ? error.message : String(error)}`, { detail: NOT_SENT })
+      });
+    }
+  });
+  return {
+    success: true,
+    data: {
+      health: ready.data,
+      alive: () => alive,
+      request,
+      async snapshot(params = {}, opts = {}) {
+        return through(await request("snapshot", { ...params }, opts), readSnapshot, "snapshot");
+      },
+      async settle(params) {
+        return through(await request("settle", params, { timeoutMs: params.timeoutMs + requestTimeoutMs }), schemaReader(settleDataSchema), "settle");
+      },
+      async typeText(text) {
+        return through(await request("typeText", { text }), schemaReader(textDataSchema), "typeText");
+      },
+      onDeath(handler) {
+        deathHandlers.push(handler);
+      },
+      async close() {
+        if (closing)
+          return;
+        closing = true;
+        if (alive && transport !== undefined) {
+          alive = false;
+          const bye = new Promise((resolve) => {
+            pending.set("shutdown", {
+              op: "shutdown",
+              resolve: () => resolve(),
+              timer: setTimeout(resolve, SHUTDOWN_WAIT_MS)
+            });
+          });
+          try {
+            transport.send(encodeRequest({ id: "shutdown", op: "shutdown" }));
+            await bye;
+          } catch {}
+        }
+        failAll(driverError("E_HELPER_CRASHED", "warden-uiad was closed"));
+        await transport?.close().catch(() => {
+          return;
+        });
+      }
+    }
+  };
+}
+function neverSent(error) {
+  const detail = error.detail;
+  return typeof detail === "object" && detail !== null && "sent" in detail && detail.sent === false;
+}
+function isBusy(error) {
+  const detail = error.detail;
+  return error.code === "E_AX_UNAVAILABLE" && typeof detail === "object" && detail !== null && "reason" in detail && detail.reason === "uiautomation_busy";
+}
+
+// ../../packages/e2e/src/driver/android/uiad-dex.generated.ts
+var UIAD_DEX = {
+  protocol: 1,
+  version: "0.3.0",
+  bytes: 31124,
+  dexSha256: "d6cb11a3bffc6b00d3ea46c4fdd1721c23973b72b0769f26c2478e7a1769be4c",
+  sourceSha256: "d03ff47b9a5890fcc8de5d76b504b05c90402edda60ac69f765c78ec8195cfdc",
+  base64: "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"
+};
+
+// ../../packages/e2e/src/driver/android/uiad-device.ts
+var UIAD_DEVICE_DIR = "/data/local/tmp";
+var UIAD_MIN_SDK = 26;
+function uiadDevicePath(dex = UIAD_DEX) {
+  return `${UIAD_DEVICE_DIR}/warden-uiad-${dex.dexSha256.slice(0, 8)}.dex`;
+}
+function uiadBuildId(dex = UIAD_DEX) {
+  return dex.dexSha256.slice(0, 8);
+}
+function uiadLaunchCommand(devicePath) {
+  return `exec env CLASSPATH=${shellQuote(devicePath)} app_process / ${UIAD_MAIN_CLASS}`;
+}
+function uiadLaunchArgv(adb, serial, devicePath) {
+  return [adb, "-s", serial, "shell", uiadLaunchCommand(devicePath)];
+}
+function uiadInstallCommand(devicePath) {
+  const part = shellQuote(`${devicePath}.part`);
+  return `cat > ${part} && chmod 444 ${part} && mv ${part} ${shellQuote(devicePath)}`;
+}
+function uiadInstallArgv(adb, serial, devicePath) {
+  return [adb, "-s", serial, "shell", uiadInstallCommand(devicePath)];
+}
+function uiadPresentCommand(devicePath, bytes) {
+  const file = shellQuote(devicePath);
+  return `[ -f ${file} ] && [ "$(wc -c < ${file} | tr -d ' ')" = ${bytes} ] && echo present`;
+}
+var bunPushDex = async (argv, bytes) => {
+  try {
+    const proc = Bun.spawn([...argv], { stdin: bytes, stdout: "pipe", stderr: "pipe", timeout: 15000 });
+    const [out, err, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    return { exitCode, output: `${out}${err}`.trim() };
+  } catch (error) {
+    return { exitCode: 127, output: error instanceof Error ? error.message : String(error) };
+  }
+};
+async function ensureUiadDex(deps) {
+  const dex = deps.dex ?? UIAD_DEX;
+  const path = uiadDevicePath(dex);
+  const present = await deps.session.run(uiadPresentCommand(path, dex.bytes));
+  if (present.success && present.data.stdout.includes("present"))
+    return { success: true, data: path };
+  const push = deps.push ?? bunPushDex;
+  const wrote = await push(uiadInstallArgv(deps.adb, deps.serial, path), Buffer.from(dex.base64, "base64"));
+  if (wrote.exitCode !== 0) {
+    return driverErr("E_IO", `cannot write warden-uiad to ${deps.serial}:${path}: ${wrote.output.slice(0, 200)}`);
+  }
+  deps.log?.(`uiad: wrote ${dex.bytes} B to ${path}`);
+  return { success: true, data: path };
+}
+var HOLDERS_COMMAND = "ps -A -o PID,ARGS";
+var FOREIGN_HOLDER = /\binstrument\b|uiautomator|UiAutomation/;
+function parseHolders(ps) {
+  const holders = [];
+  for (const line of ps.split(`
+`)) {
+    const match = /^\s*(\d+)\s+(.+?)\s*$/.exec(line);
+    const pid = Number(match?.[1]);
+    const args = match?.[2];
+    if (args === undefined || Number.isNaN(pid))
+      continue;
+    if (args.includes(UIAD_MAIN_CLASS))
+      holders.push({ pid, args, ours: true });
+    else if (FOREIGN_HOLDER.test(args) && !args.startsWith("ps "))
+      holders.push({ pid, args, ours: false });
+  }
+  return holders;
+}
+function busyError(serial, holders, cause) {
+  const named = holders.length > 0 ? holders.map((h) => `pid ${h.pid}: ${h.args}`).join("; ") : "an unknown process";
+  return driverError("E_AX_UNAVAILABLE", `another UiAutomation client holds ${serial} (${named}); warden will not touch it. Stop it, or release the device.`, {
+    retryable: false,
+    detail: { reason: "uiautomation_busy", holders, cause: cause.message }
+  });
+}
+var STALE_KILL_SETTLE_MS = 300;
+async function launchUiad(deps) {
+  const ensured = await ensureUiadDex(deps);
+  if (!ensured.success)
+    return ensured;
+  const cmd = uiadLaunchArgv(deps.adb, deps.serial, ensured.data);
+  const start = () => startUiad({
+    cmd,
+    ...deps.spawn ? { spawn: deps.spawn } : {},
+    ...deps.log ? { log: deps.log } : {},
+    ...deps.readyTimeoutMs !== undefined ? { readyTimeoutMs: deps.readyTimeoutMs } : {},
+    ...deps.requestTimeoutMs !== undefined ? { requestTimeoutMs: deps.requestTimeoutMs } : {}
+  });
+  const first = await start();
+  if (first.success || !isBusy(first.error))
+    return first;
+  const listed = await deps.session.run(HOLDERS_COMMAND);
+  const holders = listed.success ? parseHolders(listed.data.stdout) : [];
+  const stale = holders.filter((h) => h.ours);
+  if (stale.length === 0 || holders.some((h) => !h.ours))
+    return { success: false, error: busyError(deps.serial, holders, first.error) };
+  deps.log?.(`uiad: ${deps.serial} is held by our own server (pid ${stale.map((h) => h.pid).join(", ")}); killing it`);
+  await deps.session.run(`kill ${stale.map((h) => h.pid).join(" ")}`);
+  await (deps.sleep ?? Bun.sleep)(STALE_KILL_SETTLE_MS);
+  const second = await start();
+  if (second.success || !isBusy(second.error))
+    return second;
+  const again = await deps.session.run(HOLDERS_COMMAND);
+  return {
+    success: false,
+    error: busyError(deps.serial, again.success ? parseHolders(again.data.stdout) : [], second.error)
+  };
+}
+
+// ../../packages/e2e/src/driver/android/uiad-backend.ts
+var MAX_RESTARTS = 3;
+var MAX_START_FAILURES = 2;
+var CONNECT_FAILURES_TO_PERSIST = 2;
+var BUSY_BACKOFF_MS = 2000;
+var UIAD_ENV = "WARDEN_ANDROID_UIAD";
+function uiadFromEnv(env) {
+  return env[UIAD_ENV] === "0" ? undefined : true;
+}
+function isPersistentStartFailure(error) {
+  const detail = error.detail;
+  const reason = typeof detail === "object" && detail !== null && "reason" in detail ? detail.reason : undefined;
+  return error.code === "E_UNSUPPORTED" || reason === "connect_failed";
+}
+function createUiadBackend(deps) {
+  const { log, clock } = deps;
+  const launch = deps.launch ?? launchUiad;
+  let off = deps.unsupportedBuild === uiadBuildId() ? "this build does not run on this device" : undefined;
+  let current;
+  let starting;
+  let started = 0;
+  let startFailures = 0;
+  let connectFailures = 0;
+  let busy;
+  const giveUp = (why) => {
+    off = why;
+    log?.(`uiad: off for this driver (${why}); using uiautomator dump and input`);
+  };
+  async function start() {
+    if (started > MAX_RESTARTS) {
+      giveUp(`it died ${started} times`);
+      return;
+    }
+    const startedAt = Date.now();
+    const launched = await launch({
+      session: deps.session,
+      adb: deps.adb,
+      serial: deps.serial,
+      ...log ? { log } : {},
+      ...deps.options.spawn ? { spawn: deps.options.spawn } : {},
+      ...deps.options.push ? { push: deps.options.push } : {},
+      ...deps.options.readyTimeoutMs !== undefined ? { readyTimeoutMs: deps.options.readyTimeoutMs } : {},
+      ...deps.options.requestTimeoutMs !== undefined ? { requestTimeoutMs: deps.options.requestTimeoutMs } : {},
+      sleep: clock.sleep
+    });
+    addSpanDetail("uiadStartMs", Date.now() - startedAt);
+    if (launched.success) {
+      started++;
+      startFailures = 0;
+      connectFailures = 0;
+      busy = undefined;
+      current = launched.data;
+      return current;
+    }
+    return failedStart(launched.error);
+  }
+  function failedStart(error) {
+    if (isBusy(error)) {
+      busy = { error, at: clock.now() };
+      connectFailures = 0;
+      log?.(`uiad: ${error.message}`);
+      return;
+    }
+    log?.(`uiad: could not start (${error.code}: ${error.message})`);
+    busy = undefined;
+    startFailures++;
+    connectFailures = error.code !== "E_UNSUPPORTED" && isPersistentStartFailure(error) ? connectFailures + 1 : 0;
+    if (error.code === "E_UNSUPPORTED" || connectFailures >= CONNECT_FAILURES_TO_PERSIST) {
+      deps.onUnsupported?.(uiadBuildId());
+      giveUp(error.message);
+    } else if (startFailures >= MAX_START_FAILURES) {
+      giveUp(`${startFailures} starts failed in a row`);
+    }
+    return;
+  }
+  return {
+    wanted: () => off === undefined,
+    blocked: () => busy?.error,
+    status() {
+      if (off !== undefined)
+        return `off: ${off}`;
+      if (busy !== undefined)
+        return "busy";
+      return current?.alive() ? "up" : "idle";
+    },
+    async server() {
+      if (off !== undefined)
+        return;
+      if (current?.alive())
+        return current;
+      if (busy !== undefined && clock.now() - busy.at < BUSY_BACKOFF_MS)
+        return;
+      starting ??= start().finally(() => {
+        starting = undefined;
+      });
+      return starting;
+    },
+    async failed(error) {
+      log?.(`uiad: ${error.code}: ${error.message}`);
+      const dead = current;
+      current = undefined;
+      await dead?.close();
+    },
+    async stop() {
+      const live = current;
+      current = undefined;
+      await starting?.catch(() => {
+        return;
+      });
+      const late = current;
+      current = undefined;
+      await Promise.all([live?.close(), late?.close()]);
+    }
+  };
+}
+
+// ../../packages/e2e/src/driver/android/uiautomator.ts
+class UiautomatorParseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UiautomatorParseError";
+  }
+}
+var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+function decodeEntities(value) {
+  if (!value.includes("&"))
+    return value;
+  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (whole, body) => {
+    if (body.startsWith("#x"))
+      return safeCodePoint(Number.parseInt(body.slice(2), 16), whole);
+    if (body.startsWith("#"))
+      return safeCodePoint(Number.parseInt(body.slice(1), 10), whole);
+    return ENTITIES[body] ?? whole;
+  });
+}
+function safeCodePoint(code, fallback) {
+  return Number.isInteger(code) && code >= 0 && code <= 1114111 ? String.fromCodePoint(code) : fallback;
+}
+var isSpace = (ch) => /\s/.test(ch);
+function skipMarkup(xml, lt) {
+  if (xml.startsWith("<?", lt)) {
+    const end = xml.indexOf("?>", lt + 2);
+    return end < 0 ? -1 : end + 2;
+  }
+  if (xml.startsWith("<!--", lt)) {
+    const end = xml.indexOf("-->", lt + 4);
+    return end < 0 ? -1 : end + 3;
+  }
+  return;
+}
+function readAttribute(xml, from) {
+  let p = from;
+  while (p < xml.length && !/[\s=/>]/.test(xml.charAt(p)))
+    p++;
+  const key = xml.slice(from, p);
+  while (p < xml.length && isSpace(xml.charAt(p)))
+    p++;
+  if (xml.charAt(p) !== "=")
+    return { key, value: "", end: p };
+  p++;
+  while (p < xml.length && isSpace(xml.charAt(p)))
+    p++;
+  const quote = xml.charAt(p);
+  if (quote !== '"' && quote !== "'")
+    return { key, value: "", end: p };
+  const valueEnd = xml.indexOf(quote, p + 1);
+  if (valueEnd < 0)
+    return;
+  return { key, value: decodeEntities(xml.slice(p + 1, valueEnd)), end: valueEnd + 1 };
+}
+function readOpenTag(xml, lt) {
+  let p = lt + 1;
+  while (p < xml.length && !/[\s/>]/.test(xml.charAt(p)))
+    p++;
+  const name = xml.slice(lt + 1, p);
+  const attrs = new Map;
+  let selfClosing = false;
+  while (p < xml.length) {
+    const ch = xml.charAt(p);
+    if (ch === ">")
+      return { name, attrs, selfClosing, end: p + 1 };
+    if (ch === "/") {
+      selfClosing = true;
+      p++;
+    } else if (isSpace(ch)) {
+      p++;
+    } else {
+      const attribute = readAttribute(xml, p);
+      if (!attribute)
+        return;
+      attrs.set(attribute.key, attribute.value);
+      p = attribute.end;
+    }
+  }
+  return;
+}
+function* tokenize(xml) {
+  let i = 0;
+  while (i < xml.length) {
+    const lt = xml.indexOf("<", i);
+    if (lt < 0)
+      return;
+    const skipped = skipMarkup(xml, lt);
+    if (skipped !== undefined) {
+      if (skipped < 0)
+        return;
+      i = skipped;
+      continue;
+    }
+    if (xml.startsWith("</", lt)) {
+      const end = xml.indexOf(">", lt + 2);
+      if (end < 0)
+        return;
+      yield { kind: "close", name: xml.slice(lt + 2, end).trim() };
+      i = end + 1;
+      continue;
+    }
+    const tag = readOpenTag(xml, lt);
+    if (!tag)
+      return;
+    yield { kind: "open", name: tag.name, attrs: tag.attrs, selfClosing: tag.selfClosing };
+    i = tag.end;
+  }
+}
+function parseForest(xml) {
+  const roots = [];
+  const stack = [];
+  let sawHierarchy = false;
+  const open = (attrs, selfClosing) => {
+    const node = { attrs, children: [] };
+    (stack[stack.length - 1]?.children ?? roots).push(node);
+    if (!selfClosing)
+      stack.push(node);
+  };
+  for (const token of tokenize(xml)) {
+    if (token.name === "hierarchy")
+      sawHierarchy = true;
+    else if (token.name !== "node")
+      continue;
+    else if (token.kind === "close")
+      stack.pop();
+    else if (sawHierarchy)
+      open(token.attrs, token.selfClosing);
+  }
+  return sawHierarchy ? roots : undefined;
+}
+var BOUNDS = /^\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]$/;
+function parseBounds(value) {
+  const m = BOUNDS.exec(value ?? "");
+  if (!m)
+    return { x: 0, y: 0, width: 0, height: 0 };
+  const [l, t, r, b] = [Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4])];
+  return { x: l, y: t, width: Math.max(0, r - l), height: Math.max(0, b - t) };
+}
+function simpleName(cls) {
+  return cls.slice(cls.lastIndexOf(".") + 1);
+}
+var ROLE_SUFFIXES = [
+  ["ToggleButton", "switch"],
+  ["CheckBox", "checkbox"],
+  ["RadioButton", "checkbox"],
+  ["SeekBar", "slider"],
+  ["Button", "button"],
+  ["TextView", "text"],
+  ["ImageView", "image"],
+  ["RecyclerView", "list"],
+  ["ListView", "list"],
+  ["ScrollView", "scrollview"]
+];
+var CLICKABLE_CONTAINERS = new Set(["ViewGroup", "FrameLayout", "View"]);
+function roleFor(cls, flags) {
+  const name = simpleName(cls);
+  if (name.includes("Switch"))
+    return "switch";
+  if (name.endsWith("EditText"))
+    return flags.password ? "securefield" : "textfield";
+  const bySuffix = ROLE_SUFFIXES.find(([suffix]) => name.endsWith(suffix));
+  if (bySuffix)
+    return bySuffix[1];
+  return flags.clickable && CLICKABLE_CONTAINERS.has(name) ? "button" : "other";
+}
+function overlapsScreen(frame, screen) {
+  return frame.width > 0 && frame.height > 0 && frame.x < screen.width && frame.y < screen.height && frame.x + frame.width > 0 && frame.y + frame.height > 0;
+}
+function readFlags(attrs) {
+  const flag = (name) => attrs.get(name) === "true";
+  return {
+    clickable: flag("clickable"),
+    longClickable: flag("long-clickable"),
+    checkable: flag("checkable"),
+    checked: flag("checked"),
+    scrollable: flag("scrollable"),
+    selected: flag("selected"),
+    focused: flag("focused"),
+    password: flag("password"),
+    enabled: attrs.get("enabled") !== "false"
+  };
+}
+function traitsOf(f) {
+  const named = [
+    [f.clickable, "clickable"],
+    [f.longClickable, "long-clickable"],
+    [f.checkable, "checkable"],
+    [f.checked, "checked"],
+    [f.focused, "focused"],
+    [f.scrollable, "scrollable"],
+    [f.selected, "selected"],
+    [f.password, "password"]
+  ];
+  return named.filter(([on]) => on).map(([, name]) => name);
+}
+function normalize(frame, screen) {
+  if (screen.width <= 0 || screen.height <= 0)
+    return { x: 0, y: 0, width: 0, height: 0 };
+  return {
+    x: frame.x / screen.width,
+    y: frame.y / screen.height,
+    width: frame.width / screen.width,
+    height: frame.height / screen.height
+  };
+}
+function toElement(raw, id, depth, screen) {
+  const a = raw.attrs;
+  const f = readFlags(a);
+  const cls = a.get("class") ?? "";
+  const role = roleFor(cls, f);
+  const frame = parseBounds(a.get("bounds"));
+  const identifier = (a.get("resource-id") ?? "").replace(/^[^:/]+:id\//, "");
+  const label = a.get("content-desc") ?? "";
+  const text = a.get("text") ?? "";
+  const hint = a.get("hint") ?? "";
+  const isInput = role === "textfield" || role === "securefield";
+  return {
+    id,
+    role,
+    rawType: cls,
+    ...label ? { label } : {},
+    ...identifier ? { identifier } : {},
+    ...isInput ? { value: text } : {},
+    ...text ? { text } : {},
+    ...hint ? { placeholder: hint } : {},
+    frame,
+    normFrame: normalize(frame, screen),
+    traits: traitsOf(f),
+    enabled: f.enabled,
+    focused: f.focused,
+    selected: f.selected,
+    ...f.checkable ? { checked: f.checked } : {},
+    hittable: f.clickable && f.enabled && overlapsScreen(frame, screen),
+    tapPoint: { x: Math.round(frame.x + frame.width / 2), y: Math.round(frame.y + frame.height / 2) },
+    depth,
+    children: []
+  };
+}
+function flatten(elements, out = []) {
+  for (const element of elements) {
+    out.push(element);
+    flatten(element.children, out);
+  }
+  return out;
+}
+function parseUiautomatorXml(xml, screen) {
+  const start = xml.indexOf("<hierarchy");
+  if (start < 0)
+    throw new UiautomatorParseError(`no <hierarchy> in uiautomator output: ${xml.slice(0, 120)}`);
+  const end = xml.lastIndexOf("</hierarchy>");
+  const body = end >= 0 ? xml.slice(start, end + "</hierarchy>".length) : xml.slice(start);
+  const forest = parseForest(body);
+  if (!forest)
+    throw new UiautomatorParseError("unparseable uiautomator output");
+  return buildTree(forest, screen);
+}
+function buildTree(forest, screen) {
+  const build = (raw, id, depth) => {
+    const element = toElement(raw, id, depth, screen);
+    element.children = raw.children.map((child, i) => build(child, `${id}.${i}`, depth + 1));
+    return element;
+  };
+  const elements = forest.map((raw, i) => build(raw, String(i), 0));
+  return { elements, flat: flatten(elements) };
+}
+function rawFromUiad(node) {
+  const [l, t, r, b] = node.bounds;
+  const attrs = new Map;
+  const text = (key, value) => {
+    if (value !== undefined)
+      attrs.set(key, value);
+  };
+  const flag = (key, on) => {
+    if (on)
+      attrs.set(key, "true");
+  };
+  text("class", node.class);
+  text("resource-id", node.id);
+  text("text", node.text);
+  text("content-desc", node.desc);
+  text("hint", node.hint);
+  attrs.set("bounds", `[${l},${t}][${r},${b}]`);
+  flag("clickable", node.clickable);
+  flag("long-clickable", node.longClickable);
+  flag("checkable", node.checkable);
+  flag("checked", node.checked);
+  flag("scrollable", node.scrollable);
+  flag("selected", node.selected);
+  flag("focused", node.focused);
+  flag("password", node.password);
+  if (node.disabled)
+    attrs.set("enabled", "false");
+  return { attrs, children: (node.children ?? []).map(rawFromUiad) };
+}
+function parseUiadNodes(nodes, screen) {
+  return buildTree(nodes.map(rawFromUiad), screen);
+}
+function isInteractive(element) {
+  return element.traits.includes("clickable") || element.traits.includes("long-clickable") || element.traits.includes("checkable") || element.traits.includes("scrollable") || simpleName(element.rawType).endsWith("EditText");
+}
+function interactiveFilter(elements) {
+  const prune = (element) => {
+    const children = element.children.flatMap((child) => prune(child) ?? []);
+    if (!isInteractive(element) && children.length === 0)
+      return;
+    return { ...element, children };
+  };
+  const kept = elements.flatMap((element) => prune(element) ?? []);
+  return { elements: kept, flat: flatten(kept) };
+}
+
+// ../../packages/e2e/src/driver/android/uiad-ops.ts
+var REFUSALS = new Set(["E_HID", "E_NO_ELEMENT", "E_UNSUPPORTED"]);
+var SNAPSHOT_ATTEMPTS = 3;
+var SNAPSHOT_RETRY_MS = 400;
+var EDIT_QUIET_MS = 80;
+var EDIT_QUIET_TIMEOUT_MS = 1000;
+var KEY_GAP_MS = 30;
+var KEY_BASE_TIMEOUT_MS = 1e4;
+var KEY_PRESS_BUDGET_MS = 150;
+var ok3 = { success: true, data: undefined };
+function isNoWindowYet(error) {
+  return error.code === "E_AX_UNAVAILABLE" && !isBusy(error);
+}
+function snapshotFromUiad(data, baseScreen, takenAt) {
+  const screen = rotatedScreen(baseScreen, data.screen.rotation ?? 0);
+  return {
+    platform: "android",
+    backend: "uiautomator",
+    takenAt,
+    screen,
+    ...parseUiadNodes(data.elements, screen),
+    truncated: data.truncated
+  };
+}
+function createUiadOps(deps) {
+  const { backend, clock, log } = deps;
+  const blocked = () => {
+    const error = backend.blocked();
+    return error === undefined ? undefined : { success: false, error };
+  };
+  async function judge(op, error, canRetry) {
+    if (REFUSALS.has(error.code)) {
+      log?.(`uiad ${op} refused (${error.code}: ${error.message}); doing it the old way`);
+      return "fallback";
+    }
+    await backend.failed(error);
+    return neverSent(error) && canRetry ? "retry" : "surface";
+  }
+  async function call(op, use, idempotent) {
+    for (let attempt = 0;attempt < 2; attempt++) {
+      const server = await backend.server();
+      if (server === undefined)
+        return;
+      const res = await use(server);
+      if (res.success)
+        return res;
+      const verdict = await judge(op, res.error, attempt === 0);
+      if (verdict === "surface" && !idempotent)
+        return res;
+      if (verdict !== "retry")
+        return;
+    }
+    return;
+  }
+  const effect = (op, params, opts) => call(op, async (server) => mapVoid(await server.request(op, params, opts)), false);
+  const edit = (op, send) => call(op, async (server) => {
+    const sent = mapVoid(await send(server));
+    if (sent.success)
+      await server.settle({ quietMs: EDIT_QUIET_MS, timeoutMs: EDIT_QUIET_TIMEOUT_MS });
+    return sent;
+  }, false);
+  async function snapshot() {
+    for (let attempt = 1;; attempt++) {
+      const server = await backend.server();
+      if (server === undefined)
+        return blocked();
+      const res = await server.snapshot();
+      if (res.success) {
+        noteSpanDetail("backend", "uiad");
+        noteSpanDetail("uiadMs", res.data.ms);
+        return { success: true, data: snapshotFromUiad(res.data, deps.baseScreen, clock.now()) };
+      }
+      if (!isNoWindowYet(res.error)) {
+        await backend.failed(res.error);
+        return;
+      }
+      if (attempt >= SNAPSHOT_ATTEMPTS)
+        return res;
+      log?.(`uiad: no window to read yet, retrying (${attempt}/${SNAPSHOT_ATTEMPTS - 1})`);
+      await clock.sleep(SNAPSHOT_RETRY_MS);
+    }
+  }
+  async function settle(opts) {
+    const server = await backend.server();
+    if (server === undefined)
+      return blocked();
+    const res = await server.settle(opts);
+    if (!res.success) {
+      await backend.failed(res.error);
+      return;
+    }
+    noteSpanDetail("backend", "uiad");
+    noteSpanDetail("via", "stream");
+    const { quiet, waitedMs, reason } = res.data;
+    return {
+      success: true,
+      data: { quiet, waitedMs, via: "stream", ...reason !== undefined ? { reason } : {} }
+    };
+  }
+  return {
+    enabled: backend.wanted,
+    status: backend.status,
+    snapshot,
+    settle,
+    tap: (point, opts) => effect("tap", {
+      x: point.x,
+      y: point.y,
+      ...opts?.count !== undefined && opts.count > 1 ? { count: opts.count } : {},
+      ...opts?.durationMs ? { holdMs: opts.durationMs } : {}
+    }),
+    longPress: (point, durationMs = DEFAULT_LONG_PRESS_MS) => effect("tap", { x: point.x, y: point.y, holdMs: durationMs }),
+    swipe: (from, to, durationMs = DEFAULT_SWIPE_MS) => effect("swipe", { x1: from.x, y1: from.y, x2: to.x, y2: to.y, durationMs }),
+    drag: (from, to, timing) => effect("swipe", {
+      x1: from.x,
+      y1: from.y,
+      x2: to.x,
+      y2: to.y,
+      durationMs: timing.durationMs,
+      pressMs: timing.pressMs,
+      releaseMs: timing.releaseMs,
+      steps: DRAG_STEPS
+    }, { timeoutMs: KEY_BASE_TIMEOUT_MS + timing.pressMs + timing.durationMs + timing.releaseMs }),
+    gesture: (plan) => effect("gesture", { paths: plan.paths, frameMs: plan.frameMs, holdMs: plan.holdMs, releaseMs: plan.releaseMs }, { timeoutMs: KEY_BASE_TIMEOUT_MS + plan.totalMs }),
+    key: (keyCode, times = 1) => edit("key", (server) => server.request("key", { keyCode, ...times > 1 ? { times, gapMs: KEY_GAP_MS } : {} }, { timeoutMs: KEY_BASE_TIMEOUT_MS + times * KEY_PRESS_BUDGET_MS })),
+    selectAll: () => call("selectAll", async (server) => mapVoid(await server.request("selectAll")), true),
+    typeText: (text) => edit("typeText", (server) => server.typeText(text)),
+    setText: (text) => edit("setText", (server) => server.request("setText", { text })),
+    stop: () => backend.stop()
+  };
+}
+function mapVoid(result) {
+  return result.success ? ok3 : result;
+}
+
+// ../../packages/e2e/src/driver/android/android-driver.ts
+var bunExecBinary = async (argv, opts = {}) => {
+  try {
+    const proc = Bun.spawn([...argv], { stdin: "ignore", stdout: "pipe", stderr: "ignore", timeout: opts.timeoutMs });
+    const [bytes, exitCode] = await Promise.all([new Response(proc.stdout).arrayBuffer(), proc.exited]);
+    return { exitCode, stdout: new Uint8Array(bytes) };
+  } catch {
+    return { exitCode: 127, stdout: new Uint8Array };
+  }
+};
+var CAPABILITIES = {
+  pinch: false,
+  maxPointers: 0,
+  unicodeText: false,
+  nativeSettle: false,
+  alerts: true,
+  reachability: true
+};
+var DUMP_IDLE_MS = 1000;
+var DUMP_IDLE_TIMEOUT_MS = 1e4;
+var SNAPSHOT_ATTEMPTS2 = 3;
+var INPUT_TEXT_BASE_MS = 1e4;
+var INPUT_TEXT_PIECE_MS = 8000;
+var SNAPSHOT_RETRY_MS2 = 400;
+var SCREENSHOT_TIMEOUT_MS = 1e4;
+var DRAG_PRESS_MS = 500;
+var DRAG_MOVE_MS = 600;
+var DRAG_PROCESS_BUDGET_MS = 3000;
+var PNG_MAGIC = [137, 80, 78, 71];
+var unit = { success: true, data: undefined };
+function elementAt(flat, point) {
+  const inside = flat.filter((e) => point.x >= e.frame.x && point.x < e.frame.x + e.frame.width && point.y >= e.frame.y && point.y < e.frame.y + e.frame.height);
+  const deepest = (list) => list.reduce((best, e) => best === undefined || e.depth >= best.depth ? e : best, undefined);
+  return deepest(inside.filter((e) => e.hittable)) ?? deepest(inside) ?? null;
+}
+async function openAndroidDriver(options) {
+  const { serial, adb, log } = options;
+  const clock = options.clock ?? realClock;
+  const execBinary = options.execBinary ?? bunExecBinary;
+  const session = openAdbSession({
+    adb,
+    serial,
+    ...options.spawn ? { spawn: options.spawn } : {},
+    ...log ? { log } : {}
+  });
+  const failed = async (error) => {
+    await session.close();
+    return { success: false, error };
+  };
+  const savedState = options.state?.read(serial);
+  const booted = await waitForBoot(session, serial, clock, {
+    ...options.bootTimeoutMs !== undefined ? { timeoutMs: options.bootTimeoutMs } : {},
+    ...log ? { log } : {}
+  });
+  if (!booted.success)
+    return failed(booted.error);
+  const sdk = booted.data.sdk;
+  const probed = options.screen ?? booted.data.screen;
+  const screen = probed ? { success: true, data: probed } : await readScreen(session, serial);
+  if (!screen.success)
+    return failed(screen.error);
+  const saved = forSdk(await savedState ?? {}, sdk);
+  const animations = await disableAnimations({
+    session,
+    serial,
+    sdk,
+    pending: saved.animations,
+    ...options.state ? { state: options.state } : {},
+    ...log ? { log } : {}
+  });
+  return {
+    success: true,
+    data: buildDriver(options, session, screen.data, clock, execBinary, {
+      sdk,
+      savedRoute: saved.dumpRoute,
+      savedUiadUnsupported: saved.uiadUnsupported,
+      animations
+    })
+  };
+}
+function openUiad(input) {
+  const { options, session, baseScreen, clock, facts, saving } = input;
+  const { sdk } = facts;
+  const asked = options.uiad === true ? {} : options.uiad || undefined;
+  if (asked === undefined || sdk === undefined || sdk < UIAD_MIN_SDK)
+    return;
+  const { serial, adb, log, state } = options;
+  const backend = createUiadBackend({
+    session,
+    adb,
+    serial,
+    clock,
+    options: asked,
+    ...log ? { log } : {},
+    ...facts.savedUiadUnsupported !== undefined ? { unsupportedBuild: facts.savedUiadUnsupported } : {},
+    onUnsupported: (buildId) => {
+      if (state)
+        saving.push(state.update(serial, patchFor(sdk, { uiadUnsupported: buildId })));
+    }
+  });
+  return createUiadOps({ backend, baseScreen, clock, ...log ? { log } : {} });
+}
+function buildDriver(options, session, baseScreen, clock, execBinary, facts) {
+  const { serial, adb, exec, log } = options;
+  const { sdk } = facts;
+  const initialRoute = options.dumpRoute ?? facts.savedRoute;
+  const saving = [];
+  const dumper = createDumper({
+    session,
+    exec,
+    adb,
+    serial,
+    ...sdk !== undefined ? { sdk } : {},
+    ...log ? { log } : {},
+    ...initialRoute ? { initialRoute } : {},
+    onRoute: (route) => {
+      options.onDumpRoute?.(route);
+      if (options.state)
+        saving.push(options.state.update(serial, patchFor(sdk, { dumpRoute: route })));
+    }
+  });
+  const uiad = openUiad({ options, session, baseScreen, clock, facts, saving });
+  async function dumpWithRetry() {
+    let dumped = await dumper.dump();
+    for (let attempt = 1;attempt < SNAPSHOT_ATTEMPTS2 && !dumped.success && dumped.error.code === "E_AX_UNAVAILABLE"; attempt++) {
+      log?.(`uiautomator unavailable, retrying (${attempt}/${SNAPSHOT_ATTEMPTS2 - 1})`);
+      await clock.sleep(SNAPSHOT_RETRY_MS2);
+      dumped = await dumper.dump();
+    }
+    return dumped;
+  }
+  async function dumpSnapshot() {
+    noteSpanDetail("backend", "dump");
+    const dumped = await dumpWithRetry();
+    if (!dumped.success)
+      return dumped;
+    let parsed;
+    const rotation = hierarchyRotation(dumped.data.xml);
+    const screen = rotatedScreen(baseScreen, rotation);
+    try {
+      parsed = parseUiautomatorXml(dumped.data.xml, screen);
+    } catch (error) {
+      if (error instanceof UiautomatorParseError)
+        return driverErr("E_AX_UNAVAILABLE", error.message);
+      throw error;
+    }
+    const taken = {
+      platform: "android",
+      backend: "uiautomator",
+      takenAt: clock.now(),
+      screen,
+      ...parsed,
+      truncated: false
+    };
+    return { success: true, data: taken };
+  }
+  async function takeSnapshot() {
+    return await uiad?.snapshot() ?? dumpSnapshot();
+  }
+  const input = async (cmd, timeoutMs) => {
+    const res = await runChecked(session, cmd, "E_HID", timeoutMs);
+    return res.success ? unit : res;
+  };
+  const snapshot = async (opts) => {
+    if (opts?.backend !== undefined && opts.backend !== "uiautomator") {
+      return driverErr("E_UNSUPPORTED", `Android only has the uiautomator backend, not ${opts.backend}`);
+    }
+    const taken = await takeSnapshot();
+    if (!taken.success || !opts?.interactiveOnly)
+      return taken;
+    return { success: true, data: { ...taken.data, ...interactiveFilter(taken.data.elements) } };
+  };
+  const elementAtPoint = async (point) => {
+    const snap = await takeSnapshot();
+    return snap.success ? { success: true, data: elementAt(snap.data.flat, point) } : snap;
+  };
+  const tap = async (point, opts) => {
+    const t0 = clock.now();
+    const count = Math.max(1, opts?.count ?? 1);
+    const once = opts?.durationMs ? longPressArgv(point, opts.durationMs) : tapArgv(point);
+    const res = await uiad?.tap(point, { count, ...opts?.durationMs ? { durationMs: opts.durationMs } : {} }) ?? await input(Array.from({ length: count }, () => shellCommand(once)).join("; "));
+    log?.(`tap ${Math.round(point.x)},${Math.round(point.y)} x${count} in ${clock.now() - t0}ms`);
+    return res;
+  };
+  const typeText = async (text) => {
+    const fast = text === "" ? undefined : await uiad?.typeText(text);
+    if (fast !== undefined)
+      return fast;
+    const argvs = textArgvs(text);
+    if (!argvs.success)
+      return argvs;
+    if (argvs.data.length === 0)
+      return unit;
+    return input(argvs.data.map((argv) => shellCommand(argv)).join(" && "), INPUT_TEXT_BASE_MS + INPUT_TEXT_PIECE_MS * argvs.data.length);
+  };
+  const key = async (name, modifiers = []) => {
+    const code = keyNameKeycode(name);
+    if (modifiers.length === 0)
+      return await uiad?.key(code) ?? input(shellCommand(keyeventArgv(code)));
+    const res = await session.run(shellCommand(keycombinationArgv([...modifiers.map(modifierKeycode), code])));
+    if (!res.success)
+      return res;
+    return res.data.exitCode === 0 ? unit : driverErr("E_UNSUPPORTED", "key modifiers need Android 13+ (`input keycombination`)");
+  };
+  const pressKeyRepeat = async (name, times) => {
+    const argvs = keyRepeatArgvs(keyNameKeycode(name), times);
+    if (argvs.length === 0)
+      return unit;
+    const fast = await uiad?.key(keyNameKeycode(name), Math.floor(times));
+    if (fast !== undefined)
+      return fast;
+    return input(argvs.map((argv) => shellCommand(argv)).join(" && "), INPUT_TEXT_BASE_MS + INPUT_TEXT_PIECE_MS * argvs.length);
+  };
+  const selectAll = async () => {
+    const fast = await uiad?.selectAll();
+    if (fast !== undefined)
+      return fast;
+    if (sdk === undefined || sdk < SELECT_ALL_MIN_SDK) {
+      return driverErr("E_UNSUPPORTED", "select-all needs the warden-uiad server or Android 13+ (`input keycombination`)");
+    }
+    return input(shellCommand(selectAllArgv()));
+  };
+  const setText = async (text) => await uiad?.setText(text) ?? driverErr("E_UNSUPPORTED", "setText needs the warden-uiad server");
+  const drag = async (from, to, opts) => {
+    const timing = {
+      pressMs: opts?.pressMs ?? DRAG_PRESS_MS,
+      durationMs: opts?.durationMs ?? DRAG_MOVE_MS,
+      releaseMs: opts?.releaseMs ?? 0
+    };
+    const fast = await uiad?.drag(from, to, timing);
+    if (fast !== undefined)
+      return fast;
+    if (sdk === undefined || sdk < MOTIONEVENT_MIN_SDK) {
+      return input(shellCommand(swipeArgv(from, to, timing.pressMs + timing.durationMs + timing.releaseMs)));
+    }
+    const total = timing.pressMs + timing.durationMs + timing.releaseMs;
+    return input(dragMotionCommand(from, to, timing), INPUT_TEXT_BASE_MS + total + (DRAG_STEPS + 2) * DRAG_PROCESS_BUDGET_MS);
+  };
+  const runGesture = async (plan) => {
+    const fast = await uiad?.gesture(plan);
+    if (fast !== undefined)
+      return fast;
+    if (plan.paths.length > 1) {
+      return driverErr("E_UNSUPPORTED", "two-finger gestures need the warden-uiad server (API 26+, WARDEN_ANDROID_UIAD not 0)");
+    }
+    if (sdk === undefined || sdk < MOTIONEVENT_MIN_SDK) {
+      return driverErr("E_UNSUPPORTED", "gestures need Android 8+ (`input motionevent`) or the warden-uiad server");
+    }
+    return input(gestureMotionCommand(plan), INPUT_TEXT_BASE_MS + plan.totalMs + (GESTURE_LINE_MAX_MOVES + 2) * DRAG_PROCESS_BUDGET_MS);
+  };
+  const maxPointers = () => {
+    if (uiad?.enabled())
+      return 2;
+    return sdk !== undefined && sdk >= MOTIONEVENT_MIN_SDK ? 1 : 0;
+  };
+  const radius = DEFAULT_RADIUS * baseScreen.scale;
+  const pinch = async (center, scale, opts) => {
+    const plan = pinchPlan(center, scale, opts, radius);
+    return plan.success ? runGesture(plan.data) : plan;
+  };
+  const rotate = async (center, degrees, opts) => {
+    const plan = rotatePlan(center, degrees, opts, radius);
+    return plan.success ? runGesture(plan.data) : plan;
+  };
+  const gesture = async (paths, opts) => {
+    const plan = planGesture(paths, opts, maxPointers());
+    return plan.success ? runGesture(plan.data) : plan;
+  };
+  const pressButton = async (button) => {
+    const code = buttonKeycode(button);
+    if (code === undefined)
+      return driverErr("E_UNSUPPORTED", `Android has no ${button} button`);
+    return await uiad?.key(code) ?? input(shellCommand(keyeventArgv(code)));
+  };
+  const screenshot = async (opts) => {
+    const res = await execBinary(screencapArgv(adb, serial), { timeoutMs: SCREENSHOT_TIMEOUT_MS });
+    if (res.exitCode !== 0 || !PNG_MAGIC.every((b, i) => res.stdout[i] === b)) {
+      return driverErr("E_IO", `screencap on ${serial} gave no PNG (exit ${res.exitCode}, ${res.stdout.length} bytes)`);
+    }
+    if (!opts?.path)
+      return { success: true, data: { png: res.stdout } };
+    try {
+      await mkdir2(dirname2(opts.path), { recursive: true });
+      await writeFile2(opts.path, res.stdout);
+    } catch (error) {
+      return driverErr("E_IO", `cannot write ${opts.path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { success: true, data: { path: opts.path } };
+  };
+  const orientation = async (set) => {
+    if (set) {
+      for (const argv of rotationArgvs(orientationToRotation(set))) {
+        const res = await input(shellCommand(argv));
+        if (!res.success)
+          return res;
+      }
+      return { success: true, data: set };
+    }
+    const res = await session.run(shellCommand(userRotationArgv()));
+    if (!res.success)
+      return res;
+    const n = Number.parseInt(res.data.stdout.trim(), 10);
+    return { success: true, data: rotationToOrientation(Number.isNaN(n) ? 0 : n) };
+  };
+  const settle = async (opts) => {
+    const quietMs = opts?.quietMs ?? DEFAULT_SETTLE_QUIET_MS;
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_SETTLE_TIMEOUT_MS;
+    const fast = await uiad?.settle({ quietMs, timeoutMs });
+    if (fast !== undefined)
+      return fast;
+    if (quietMs <= DUMP_IDLE_MS) {
+      const start = clock.now();
+      const taken = await dumpSnapshot();
+      const waitedMs = clock.now() - start;
+      noteSpanDetail("via", "snapshot");
+      return {
+        success: true,
+        data: { quiet: taken.success && waitedMs < DUMP_IDLE_TIMEOUT_MS, waitedMs, via: "snapshot" }
+      };
+    }
+    const poll = async () => {
+      const taken = await takeSnapshot();
+      if (!taken.success)
+        return "unavailable";
+      return snapshotHash({ flat: taken.data.flat.map((e) => ({ ...e, value: e.value ?? e.text })) });
+    };
+    const outcome = await settleByHash(poll, {
+      quietMs,
+      timeoutMs,
+      now: clock.now,
+      sleep: clock.sleep
+    });
+    noteSpanDetail("via", "hash");
+    return { success: true, data: { ...outcome, via: "hash" } };
+  };
+  const alert = async () => {
+    const taken = await takeSnapshot();
+    return taken.success ? { success: true, data: detectAlert(taken.data.flat) } : taken;
+  };
+  const appearance = async (set) => {
+    if (set) {
+      const res = await runChecked(session, shellCommand(uimodeSetArgv(set === "dark")), "E_UNSUPPORTED");
+      return res.success ? { success: true, data: set } : res;
+    }
+    const res = await runChecked(session, shellCommand(uimodeGetArgv()), "E_UNSUPPORTED");
+    if (!res.success)
+      return res;
+    return { success: true, data: /Night mode:\s*yes/i.test(res.data) ? "dark" : "light" };
+  };
+  const clipboard = async () => driverErr("E_UNSUPPORTED", "Android has no public shell clipboard access; type ASCII with typeText");
+  const health = async () => {
+    const [release, sdk, model] = await Promise.all(["ro.build.version.release", "ro.build.version.sdk", "ro.product.model"].map((k) => session.run(shellCommand(getpropArgv(k)))));
+    const text = (r) => r?.success ? r.data.stdout.trim() : "";
+    const info = {
+      platform: "android",
+      id: serial,
+      version: `Android ${text(release)} (sdk ${text(sdk)})`,
+      transport: "adb",
+      screen: baseScreen,
+      detail: { model: text(model), dumpRoute: dumper.route() ?? null, uiad: uiad?.status() ?? "off" }
+    };
+    return { success: true, data: info };
+  };
+  return {
+    platform: "android",
+    id: serial,
+    get capabilities() {
+      return uiad?.enabled() ? { ...CAPABILITIES, pinch: true, maxPointers: 2, unicodeText: true, nativeSettle: true } : { ...CAPABILITIES, maxPointers: maxPointers() };
+    },
+    health,
+    snapshot,
+    elementAtPoint,
+    tap,
+    longPress: async (point, opts) => await uiad?.longPress(point, opts?.durationMs) ?? input(shellCommand(longPressArgv(point, opts?.durationMs))),
+    swipe: async (from, to, opts) => await uiad?.swipe(from, to, opts?.durationMs) ?? input(shellCommand(swipeArgv(from, to, opts?.durationMs))),
+    drag,
+    pinch,
+    rotate,
+    gesture,
+    typeText,
+    key,
+    pressKeyRepeat,
+    ...uiad !== undefined || sdk !== undefined && sdk >= SELECT_ALL_MIN_SDK ? { selectAll } : {},
+    ...uiad !== undefined ? { setText } : {},
+    pressButton,
+    screenshot,
+    orientation,
+    settle,
+    alert,
+    alertIn: (snapshot) => detectAlert(snapshot.flat),
+    appearance,
+    clipboard,
+    app: createAppCommands({
+      session,
+      exec,
+      adb,
+      serial,
+      ...log ? { log } : {},
+      ...options.appPackage ? { appPackage: options.appPackage } : {}
+    }),
+    close: async () => {
+      await uiad?.stop();
+      await facts.animations.restore();
+      await Promise.all(saving.splice(0));
+      await session.close();
+    }
+  };
+}
+
+// ../../packages/e2e/src/driver/ios/ios-driver.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
+
+// ../../packages/e2e/src/driver/ios/ios-session.ts
+var SHUTDOWN_TIMEOUT_MS = 500;
+function swappableClient(initial, o) {
+  let current = initial;
+  let generation = 0;
+  let restarting;
+  const request = async (op, params, opts) => {
+    const started = o.now();
+    const result = await current.request(op, params, opts);
+    if (o.debug) {
+      const failure = result.success ? "" : ` ${result.error.code}`;
+      o.log?.(`[ios] op ${op} ${Math.round(o.now() - started)} ms${failure}`);
+    }
+    return result;
+  };
+  const client = {
+    get ready() {
+      return current.ready;
+    },
+    request,
+    close: () => current.close()
+  };
+  async function doRestart(crashed) {
+    const { reopen } = o;
+    if (!reopen)
+      return { success: false, error: driverError("E_INTERNAL", "no way to reopen warden-simd") };
+    const stale = current;
+    if (!crashed)
+      await stale.request("shutdown", {}, { timeoutMs: SHUTDOWN_TIMEOUT_MS });
+    await stale.close();
+    const next = await reopen();
+    if (!next.success)
+      return next;
+    current = next.data;
+    generation += 1;
+    return { success: true, data: undefined };
+  }
+  return {
+    client,
+    generation: () => generation,
+    restart(seenGeneration, r) {
+      if (seenGeneration !== generation)
+        return Promise.resolve({ success: true, data: undefined });
+      restarting ??= doRestart(r?.crashed === true).finally(() => {
+        restarting = undefined;
+      });
+      return restarting;
+    }
+  };
+}
+
+// ../../packages/e2e/src/driver/ios/locate-helper.ts
+import { existsSync, realpathSync } from "fs";
+import { dirname as dirname3, join as join4, resolve } from "path";
+var HELPER_NAME = "warden-simd";
+var DOCTOR_HINT = "run `warden doctor` to check the iOS driver helper, or set WARDEN_SIMD=/path/to/warden-simd";
+function locateHelper(input) {
+  const resolveLink = input.realpath ?? ((path) => path);
+  const realpath = (path) => {
+    try {
+      return resolveLink(path);
+    } catch {
+      return path;
+    }
+  };
+  const tried = [];
+  const missing = (message) => ({
+    success: false,
+    error: driverError("E_HELPER_MISSING", `${message}; ${DOCTOR_HINT}`, { detail: { tried } })
+  });
+  const explicitFile = input.env[ENV_NAMES.simd];
+  if (explicitFile) {
+    tried.push(explicitFile);
+    return input.exists(explicitFile) ? { success: true, data: { path: explicitFile, source: "WARDEN_SIMD" } } : missing(`WARDEN_SIMD=${explicitFile} does not exist`);
+  }
+  const helperDir = input.env[ENV_NAMES.helperDir];
+  if (helperDir) {
+    const candidate = join4(helperDir, HELPER_NAME);
+    tried.push(candidate);
+    return input.exists(candidate) ? { success: true, data: { path: candidate, source: "WARDEN_HELPER_DIR" } } : missing(`WARDEN_HELPER_DIR=${helperDir} has no ${HELPER_NAME}`);
+  }
+  const candidates = [
+    { path: join4(dirname3(realpath(input.execPath)), HELPER_NAME), source: "execPath" },
+    { path: resolve(input.importDir, "../../../native/dist", HELPER_NAME), source: "source-build" }
+  ];
+  if (input.version) {
+    candidates.push({ path: join4(input.wardenHome, "simd", input.version, HELPER_NAME), source: "warden-home" });
+  }
+  for (const candidate of candidates) {
+    tried.push(candidate.path);
+    if (input.exists(candidate.path))
+      return { success: true, data: candidate };
+  }
+  return missing(`${HELPER_NAME} not found (tried ${tried.join(", ")})`);
+}
+function resolveHelper(o) {
+  if (o.helperPath !== undefined)
+    return { success: true, data: o.helperPath };
+  const located = locateHelper({
+    env: { [ENV_NAMES.simd]: o.env?.simd, [ENV_NAMES.helperDir]: o.env?.helperDir },
+    execPath: o.execPath ?? process.execPath,
+    importDir: o.importDir ?? import.meta.dir,
+    wardenHome: o.wardenHome ?? wardenHome(),
+    exists: o.exists ?? existsSync,
+    realpath: o.realpath ?? realpathSync,
+    ...o.version ? { version: o.version } : {}
+  });
+  return located.success ? { success: true, data: located.data.path } : located;
+}
+
+// ../../packages/e2e/src/driver/ios/normalize.ts
+function normFrameOf(frame, screen) {
+  if (screen.width <= 0 || screen.height <= 0)
+    return { x: 0, y: 0, width: 0, height: 0 };
+  return {
+    x: frame.x / screen.width,
+    y: frame.y / screen.height,
+    width: frame.width / screen.width,
+    height: frame.height / screen.height
+  };
+}
+var STRING_FIELDS2 = ["label", "identifier", "value", "text", "placeholder"];
+var FLAG_FIELDS2 = ["focused", "hidden", "selected", "checked", "hittable"];
+function optionalFields(node) {
+  const fields = {};
+  for (const key of STRING_FIELDS2) {
+    const value = node[key];
+    if (typeof value === "string")
+      fields[key] = value;
+  }
+  for (const key of FLAG_FIELDS2) {
+    const value = node[key];
+    if (typeof value === "boolean")
+      fields[key] = value;
+  }
+  if (node.traits?.includes("is-editing"))
+    fields.focused = true;
+  if (node.tapPoint)
+    fields.tapPoint = node.tapPoint;
+  if (typeof node.pid === "number")
+    fields.pid = node.pid;
+  return fields;
+}
+function normalizeElements(wire, screen, prefix = "", depth = 0) {
+  const flat = [];
+  const elements = wire.map((node, index) => {
+    const path = prefix === "" ? String(index) : `${prefix}.${index}`;
+    const element = {
+      ...optionalFields(node),
+      id: node.id ?? path,
+      role: node.role,
+      rawType: node.rawType,
+      frame: node.frame,
+      depth: node.depth ?? depth,
+      normFrame: node.normFrame ?? normFrameOf(node.frame, screen),
+      traits: node.traits ?? [],
+      enabled: node.enabled ?? !(node.traits ?? []).includes("not-enabled"),
+      children: []
+    };
+    flat.push(element);
+    const inner = normalizeElements(node.children ?? [], screen, path, depth + 1);
+    element.children = inner.elements;
+    flat.push(...inner.flat);
+    return element;
+  });
+  return { elements, flat };
+}
+function normalizeElement(wire, screen) {
+  const [element] = normalizeElements([wire], screen).elements;
+  if (!element)
+    throw new Error("normalizeElement: no element");
+  return element;
+}
+function toSnapshot(data, takenAt) {
+  const { elements, flat } = normalizeElements(data.elements, data.screen);
+  const snapshot = {
+    platform: "ios",
+    backend: data.backend,
+    takenAt,
+    screen: data.screen,
+    elements,
+    flat,
+    truncated: data.truncated
+  };
+  if (data.modal)
+    snapshot.modal = data.modal;
+  return snapshot;
+}
+
+// ../../packages/e2e/src/driver/ios/simctl.ts
+import { mkdtemp, readFile as readFile2, rm as rm2 } from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { join as join5 } from "path";
+
+// ../../packages/core/src/builds/install.ts
+import { mkdir as mkdir3, readdir, rm, stat } from "fs/promises";
+var INSTALL_TIMEOUT_MS = 10 * 60000;
+function probeArgv(target, bundleId, env) {
+  return target.platform === "ios" ? ["xcrun", "simctl", "get_app_container", target.deviceId, bundleId] : [androidTools(env).adb, "-s", target.deviceId, "shell", "pm", "path", bundleId];
+}
+async function probeApp(deps, target, bundleId) {
+  const res = await deps.exec(probeArgv(target, bundleId, deps.env));
+  if (target.platform === "ios") {
+    const container = res.stdout.trim();
+    return ok(res.exitCode === 0 && container !== "" ? { present: true, container } : { present: false });
+  }
+  return ok({ present: res.exitCode === 0 && res.stdout.includes("package:") });
+}
+async function isAppInstalled(deps, target, bundleId) {
+  const probed = await probeApp(deps, target, bundleId);
+  return probed.success ? ok(probed.data.present) : probed;
+}
+var nodeResetFs = {
+  readdir: (dir) => readdir(dir),
+  rm: (path) => rm(path, { recursive: true, force: true }),
+  mkdir: async (path) => {
+    await mkdir3(path, { recursive: true });
+  }
+};
+var CONTAINER_METADATA = ".com.apple.mobile_container_manager.metadata.plist";
+var DATA_SUBDIRS = ["Documents", "Library/Caches", "Library/Preferences", "tmp"];
+function resetArgv(target, bundleId, env) {
+  return target.platform === "ios" ? ["xcrun", "simctl", "privacy", target.deviceId, "reset", "all", bundleId] : [androidTools(env).adb, "-s", target.deviceId, "shell", "pm", "clear", bundleId];
+}
+async function wipeDir(fs, dir) {
+  for (const entry of await fs.readdir(dir)) {
+    if (entry !== CONTAINER_METADATA)
+      await fs.rm(`${dir}/${entry}`);
+  }
+}
+async function wipeGroups(deps, udid, bundleId) {
+  const groups = await deps.exec(["xcrun", "simctl", "get_app_container", udid, bundleId, "groups"]);
+  if (groups.exitCode !== 0)
+    return;
+  for (const line of groups.stdout.split(`
+`)) {
+    const [, ...rest] = line.trim().split(/\s+/);
+    const path = rest.join(" ");
+    if (path !== "")
+      await wipeDir(deps.fs, path);
+  }
+}
+async function resetIos(deps, target, bundleId, opts) {
+  const udid = target.deviceId;
+  await deps.exec(["xcrun", "simctl", "terminate", udid, bundleId]);
+  await deps.exec(["xcrun", "simctl", "spawn", udid, "defaults", "delete", bundleId]);
+  const dataArgv = ["xcrun", "simctl", "get_app_container", udid, bundleId, "data"];
+  const data = await deps.exec(dataArgv);
+  const dataDir = data.stdout.trim();
+  if (data.exitCode !== 0 || dataDir === "")
+    return err(`data container not found: ${execError(dataArgv, data)}`);
+  try {
+    await wipeDir(deps.fs, dataDir);
+    for (const sub of DATA_SUBDIRS)
+      await deps.fs.mkdir(`${dataDir}/${sub}`);
+    await wipeGroups(deps, udid, bundleId);
+  } catch (e) {
+    return err(`wiping app data failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const privacy = resetArgv(target, bundleId, deps.env);
+  const priv = await deps.exec(privacy);
+  if (priv.exitCode !== 0)
+    return err(`privacy reset failed: ${execError(privacy, priv)}`);
+  return opts.keychain ? resetSimKeychain(deps, target) : ok(undefined);
+}
+async function resetSimKeychain(deps, target) {
+  if (target.platform !== "ios")
+    return ok(undefined);
+  const argv = ["xcrun", "simctl", "keychain", target.deviceId, "reset"];
+  const res = await deps.exec(argv);
+  return res.exitCode === 0 ? ok(undefined) : err(`keychain reset failed: ${execError(argv, res)}`);
+}
+async function resetAppData(deps, target, bundleId, opts = {}) {
+  const present = await isAppInstalled(deps, target, bundleId);
+  if (!present.success)
+    return present;
+  if (!present.data)
+    return err(`${bundleId} is not installed on ${target.deviceId}`);
+  if (target.platform === "ios")
+    return resetIos(deps, target, bundleId, opts);
+  const argv = resetArgv(target, bundleId, deps.env);
+  const res = await deps.exec(argv);
+  if (res.exitCode !== 0 || !res.stdout.includes("Success"))
+    return err(`pm clear failed: ${execError(argv, res)}`);
+  return ok(undefined);
+}
+
+// ../../packages/e2e/src/driver/ios/simctl.ts
+var XCRUN = ["xcrun", "simctl"];
+var PLIST_READ_MS = 2000;
+var SHORT_MS = 15000;
+var LAUNCH_MS = 30000;
+var INSTALL_MS = 10 * 60000;
+var SIMCTL_CHILD_PREFIX = "SIMCTL_CHILD_";
+function launchArgv(udid, bundleId, opts = {}) {
+  return [
+    ...XCRUN,
+    "launch",
+    ...opts.relaunch === false ? [] : ["--terminate-running-process"],
+    udid,
+    bundleId,
+    ...opts.args ?? []
+  ];
+}
+function launchEnv(env) {
+  return Object.fromEntries(Object.entries(env ?? {}).map(([key, value]) => [`${SIMCTL_CHILD_PREFIX}${key}`, value]));
+}
+var terminateArgv = (udid, bundleId) => [...XCRUN, "terminate", udid, bundleId];
+var openUrlArgv = (udid, url) => [...XCRUN, "openurl", udid, url];
+var installArgv2 = (udid, appPath) => [...XCRUN, "install", udid, appPath];
+var uninstallArgv2 = (udid, bundleId) => [...XCRUN, "uninstall", udid, bundleId];
+var appContainerArgv = (udid, bundleId) => [
+  ...XCRUN,
+  "get_app_container",
+  udid,
+  bundleId
+];
+var launchctlListArgv = (udid) => [...XCRUN, "spawn", udid, "launchctl", "list"];
+var pbpasteArgv = (udid) => [...XCRUN, "pbpaste", udid];
+var appearanceArgv = (udid, set) => [
+  ...XCRUN,
+  "ui",
+  udid,
+  "appearance",
+  ...set ? [set] : []
+];
+var screenshotArgv = (udid, path) => [
+  ...XCRUN,
+  "io",
+  udid,
+  "screenshot",
+  "--type=png",
+  path
+];
+var automationArgv = (udid) => [
+  ...XCRUN,
+  "spawn",
+  udid,
+  "defaults",
+  "write",
+  "com.apple.Accessibility",
+  "AutomationEnabled",
+  "-bool",
+  "true"
+];
+var defaultDevicesRoot = () => join5(homedir(), "Library", "Developer", "CoreSimulator", "Devices");
+var automationPlistPath = (devicesRoot, udid) => join5(devicesRoot, udid, "data", "Library", "Preferences", "com.apple.Accessibility.plist");
+var automationReadArgv = (plist) => [
+  "plutil",
+  "-extract",
+  "AutomationEnabled",
+  "raw",
+  "-o",
+  "-",
+  plist
+];
+function statusBarOverrideArgv(udid, o = {}) {
+  const time = o.time ?? "9:41";
+  const flags = [
+    ["--time", time],
+    ["--batteryState", o.batteryState ?? "charged"],
+    ["--batteryLevel", String(o.batteryLevel ?? 100)],
+    ["--wifiBars", String(o.wifiBars ?? 3)],
+    ["--cellularBars", String(o.cellularBars ?? 4)]
+  ];
+  return [...XCRUN, "status_bar", udid, "override", ...flags.flat()];
+}
+var statusBarClearArgv = (udid) => [...XCRUN, "status_bar", udid, "clear"];
+function pbcopyArgv(udid, text) {
+  return ["sh", "-c", 'printf %s "$1" | xcrun simctl pbcopy "$2"', "sh", text, udid];
+}
+function devicectlPbcopyArgv(udid, text) {
+  return [
+    "sh",
+    "-c",
+    'printf %s "$1" | xcrun devicectl device pasteboard copy --quiet --device "$2"',
+    "sh",
+    text,
+    udid
+  ];
+}
+var PBCOPY_CHANNELS = [
+  { name: "devicectl pasteboard copy", argv: devicectlPbcopyArgv },
+  { name: "simctl pbcopy", argv: pbcopyArgv }
+];
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseRunning(launchctlOutput, bundleId) {
+  const row = new RegExp(`^\\s*(\\d+)\\s+\\S+\\s+UIKitApplication:${escapeRegExp(bundleId)}\\[`, "m");
+  return row.test(launchctlOutput);
+}
+function simctlFailure(argv, res, appCommand = false) {
+  const text = `${res.stderr}
+${res.stdout}`;
+  const message = execError(argv, res);
+  const detail = { argv, exitCode: res.exitCode };
+  if (/current state:\s*(Shutdown|Creating|Shutting Down)/i.test(text) || /Unable to .* not booted/i.test(text)) {
+    return driverError("E_NOT_BOOTED", message, { detail });
+  }
+  if (/Invalid device|No devices are booted|device .* not found/i.test(text)) {
+    return driverError("E_UNKNOWN_DEVICE", message, { detail });
+  }
+  if (appCommand && /not installed|found nothing|FBSOpenApplicationServiceErrorDomain|No such (file|app)|unknown app/i.test(text)) {
+    return driverError("E_APP_UNAVAILABLE", message, { detail });
+  }
+  return driverError("E_IO", message, { detail });
+}
+var ok4 = (data) => ({ success: true, data });
+function createSimctl(deps) {
+  const { udid, exec } = deps;
+  const env = deps.env ?? {};
+  async function run(argv, timeoutMs, appCommand = false, envOverride) {
+    const res = await exec(argv, { timeoutMs, ...envOverride ? { env: envOverride } : {} });
+    return res.exitCode === 0 ? { ok: true, res } : { ok: false, error: simctlFailure(argv, res, appCommand) };
+  }
+  async function runVoid(argv, timeoutMs = SHORT_MS, appCommand = false) {
+    const result = await run(argv, timeoutMs, appCommand);
+    return result.ok ? ok4(undefined) : { success: false, error: result.error };
+  }
+  const probe = async (bundleId) => {
+    const argv = appContainerArgv(udid, bundleId);
+    const res = await exec(argv, { timeoutMs: SHORT_MS });
+    return res.exitCode === 0 && res.stdout.trim() !== "";
+  };
+  async function screenshotToScratch() {
+    const dir = await (deps.scratchDir ?? (() => mkdtemp(join5(tmpdir(), "warden-shot-"))))();
+    const file = join5(dir, "screen.png");
+    try {
+      const done = await runVoid(screenshotArgv(udid, file), LAUNCH_MS);
+      if (!done.success)
+        return done;
+      const bytes = await (deps.readFile ?? ((p) => readFile2(p)))(file);
+      return ok4({ png: new Uint8Array(bytes) });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return { success: false, error: driverError("E_IO", `reading screenshot: ${reason}`) };
+    } finally {
+      await (deps.rmDir ?? ((p) => rm2(p, { recursive: true, force: true })))(dir).catch(() => {
+        return;
+      });
+    }
+  }
+  return {
+    async launch(bundleId, opts = {}) {
+      const result = await run(launchArgv(udid, bundleId, opts), LAUNCH_MS, true, launchEnv(opts.env));
+      return result.ok ? ok4(undefined) : { success: false, error: result.error };
+    },
+    async terminate(bundleId) {
+      const argv = terminateArgv(udid, bundleId);
+      const res = await exec(argv, { timeoutMs: SHORT_MS });
+      if (res.exitCode === 0 || /found nothing to terminate/i.test(`${res.stderr}${res.stdout}`))
+        return ok4(undefined);
+      return { success: false, error: simctlFailure(argv, res) };
+    },
+    openUrl: (url) => runVoid(openUrlArgv(udid, url), SHORT_MS, true),
+    install: (path) => runVoid(installArgv2(udid, path), INSTALL_MS),
+    async uninstall(bundleId) {
+      if (!await probe(bundleId))
+        return ok4(undefined);
+      return runVoid(uninstallArgv2(udid, bundleId), INSTALL_MS);
+    },
+    async isInstalled(bundleId) {
+      return ok4(await probe(bundleId));
+    },
+    async isRunning(bundleId) {
+      const result = await run(launchctlListArgv(udid), SHORT_MS);
+      return result.ok ? ok4(parseRunning(result.res.stdout, bundleId)) : { success: false, error: result.error };
+    },
+    async clearData(bundleId, opts = {}) {
+      const reset = await resetAppData({ exec, env, fs: deps.resetFs ?? nodeResetFs }, { platform: "ios", deviceId: udid }, bundleId, opts.keychain ? { keychain: true } : {});
+      if (reset.success)
+        return ok4(undefined);
+      const code = /is not installed/.test(reset.error) ? "E_APP_UNAVAILABLE" : "E_IO";
+      return { success: false, error: driverError(code, reset.error) };
+    },
+    async pbcopy(text) {
+      const outcomes = [];
+      for (const channel of PBCOPY_CHANNELS) {
+        const copied = await exec(channel.argv(udid, text), { timeoutMs: SHORT_MS });
+        if (copied.exitCode !== 0) {
+          outcomes.push(`${channel.name} exit ${copied.exitCode}`);
+          continue;
+        }
+        const read = await run(pbpasteArgv(udid), SHORT_MS);
+        if (!read.ok)
+          return { success: false, error: read.error };
+        if (read.res.stdout === text)
+          return ok4(undefined);
+        outcomes.push(`${channel.name} exit 0 but pbpaste reads other text`);
+      }
+      return {
+        success: false,
+        error: driverError("E_IO", `simulator pasteboard did not take the text (${outcomes.join("; ")})`)
+      };
+    },
+    async pbpaste() {
+      const result = await run(pbpasteArgv(udid), SHORT_MS);
+      return result.ok ? ok4(result.res.stdout) : { success: false, error: result.error };
+    },
+    async appearance(set) {
+      if (set) {
+        const done = await runVoid(appearanceArgv(udid, set));
+        return done.success ? ok4(set) : done;
+      }
+      const result = await run(appearanceArgv(udid), SHORT_MS);
+      if (!result.ok)
+        return { success: false, error: result.error };
+      const value = result.res.stdout.trim();
+      if (value === "light" || value === "dark")
+        return ok4(value);
+      return { success: false, error: driverError("E_UNSUPPORTED", `simctl ui appearance reported \`${value}\``) };
+    },
+    statusBar: (overrides) => runVoid(overrides === "clear" ? statusBarClearArgv(udid) : statusBarOverrideArgv(udid, overrides)),
+    async screenshot(path) {
+      if (!path)
+        return screenshotToScratch();
+      const done = await runVoid(screenshotArgv(udid, path), LAUNCH_MS);
+      return done.success ? ok4({ path }) : done;
+    },
+    enableAutomation: async () => {
+      const plist = automationPlistPath(deps.devicesRoot ?? defaultDevicesRoot(), udid);
+      const current = await exec(automationReadArgv(plist), { timeoutMs: PLIST_READ_MS }).catch(() => {
+        return;
+      });
+      if (current?.exitCode === 0 && current.stdout.trim() === "true")
+        return ok4(undefined);
+      return runVoid(automationArgv(udid));
+    }
+  };
+}
+
+// ../../packages/e2e/src/driver/ios/type-budget.ts
+var TYPE_BASE_MS = 1e4;
+var TYPE_PER_CHAR_MS = 70;
+var TYPE_PER_REPEAT_MS = 300;
+function typeTextBudgetMs(text) {
+  const characters = Array.from(text);
+  let repeats = 0;
+  for (let index = 1;index < characters.length; index += 1) {
+    if (characters[index] === characters[index - 1])
+      repeats += 1;
+  }
+  return TYPE_BASE_MS + characters.length * TYPE_PER_CHAR_MS + repeats * TYPE_PER_REPEAT_MS;
+}
+
+// ../../packages/e2e/src/driver/ios/ios-driver.ts
+var DEFAULT_QUIET_MS = 250;
+var DEFAULT_SETTLE_TIMEOUT_MS2 = 5000;
+var SETTLE_MARGIN_MS = 2000;
+var REBIND_TIMEOUT_MS = 3000;
+var GESTURE_MARGIN_MS = 5000;
+var FRONTMOST_TIMEOUT_MS = 3000;
+var KEY_USAGE = {
+  Enter: 40,
+  Escape: 41,
+  Backspace: 42,
+  Tab: 43,
+  Space: 44,
+  Delete: 76,
+  Right: 79,
+  Left: 80,
+  Down: 81,
+  Up: 82
+};
+var BUTTONS = {
+  home: "home",
+  lock: "lock",
+  volumeUp: "volumeUp",
+  volumeDown: "volumeDown",
+  shake: "shake"
+};
+var SCREENSHOT_FALLBACK = new Set(["E_UNSUPPORTED", "E_IO", "E_BAD_REQUEST", "E_INTERNAL"]);
+var RETRIED_AFTER_CRASH = new Set([
+  "snapshot",
+  "health",
+  "alertButtons",
+  "frontmost",
+  "settle",
+  "elementAtPoint",
+  "screenshot"
+]);
+var SOCKET_RETRY_MS = 500;
+function params(values) {
+  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
+}
+var okVoid = { success: true, data: undefined };
+function fail(error) {
+  return { success: false, error };
+}
+function nativeDetail(data) {
+  const { quiet, waitedMs, via, reason, frontmostPid } = data;
+  const detail = {
+    quiet,
+    waitedMs,
+    ...via === undefined ? {} : { via },
+    ...reason === undefined ? {} : { reason },
+    ...frontmostPid === undefined ? {} : { frontmostPid }
+  };
+  if (via !== undefined)
+    noteSpanDetail("via", via);
+  if (reason !== undefined)
+    noteSpanDetail("reason", reason);
+  if (frontmostPid !== undefined)
+    noteSpanDetail("frontmostPid", frontmostPid);
+  return detail;
+}
+
+class DriverFailure extends Error {
+  error;
+  constructor(error) {
+    super(error.message);
+    this.error = error;
+  }
+}
+function restOf(error, text) {
+  const detail = error.detail;
+  if (typeof detail === "object" && detail !== null && "rest" in detail && typeof detail.rest === "string") {
+    return detail.rest;
+  }
+  return text.length === 0 ? "" : undefined;
+}
+function decodeBase64(png) {
+  return new Uint8Array(Buffer.from(png, "base64"));
+}
+function createIosDriver(swap, simctl, opts) {
+  const { udid, now, sleep } = opts;
+  const { client } = swap;
+  let axFailures = 0;
+  let launchedBundle;
+  const { ready } = client;
+  const nativeSettle = ready.ax.default === "axbridge" && ready.ax.bridge === "available";
+  const bridgeUp = ready.ax.bridge === "available";
+  let settleUnsupported = !nativeSettle;
+  let rebindUnsupported = false;
+  let gestureUnsupported = false;
+  const capabilities = {
+    pinch: true,
+    maxPointers: 2,
+    unicodeText: true,
+    nativeSettle,
+    alerts: true,
+    reachability: true,
+    cheapHitTest: true
+  };
+  let lost;
+  let answeredGeneration = swap.generation();
+  async function replaceLost(op, seen, crash) {
+    if (seen !== swap.generation())
+      return;
+    if (seen !== answeredGeneration)
+      return crash;
+    opts.log?.(`[ios] warden-simd went away during \`${op}\` (E_HELPER_CRASHED: ${crash.message}); reconnecting`);
+    const restarted = await swap.restart(seen, { crashed: true });
+    if (restarted.success)
+      return;
+    const why = `${restarted.error.code}: ${restarted.error.message}`;
+    opts.log?.(`[ios] could not replace warden-simd (${why})`);
+    lost ??= driverError("E_HELPER_CRASHED", `${crash.message}; could not replace it (${why})`, { retryable: false });
+    return lost;
+  }
+  async function request(op, p = {}, o = {}) {
+    if (lost)
+      return fail(lost);
+    const seen = swap.generation();
+    const first = await client.request(op, p, o);
+    if (first.success) {
+      answeredGeneration = seen;
+      return first;
+    }
+    if (first.error.code !== "E_HELPER_CRASHED")
+      return first;
+    const stop = await replaceLost(op, seen, first.error);
+    if (stop)
+      return fail(stop);
+    if (!RETRIED_AFTER_CRASH.has(op))
+      return first;
+    const generation = swap.generation();
+    const again = await client.request(op, p, o);
+    if (again.success)
+      answeredGeneration = generation;
+    return again;
+  }
+  const send = (op, p = {}, timeoutMs) => request(op, p, timeoutMs === undefined ? {} : { timeoutMs });
+  const sendVoid = async (op, p = {}, timeoutMs) => {
+    const result = await send(op, p, timeoutMs);
+    return result.success ? okVoid : result;
+  };
+  const gestureTimeout = (durationMs, base = 0) => (durationMs ?? 0) + base + GESTURE_MARGIN_MS;
+  const helperOutdated = () => fail(driverError("E_UNSUPPORTED", `this warden-simd predates the gesture op: restart the helper (warden ui close --udid ${udid}) or rebuild it (bun run --cwd packages/e2e native:build)`, { detail: { reason: "helper_outdated" } }));
+  const sendGesture = async (planned) => {
+    if (!planned.success)
+      return planned;
+    if (gestureUnsupported)
+      return helperOutdated();
+    const plan = planned.data;
+    const result = await sendVoid("gesture", { paths: plan.paths, frameMs: plan.frameMs, holdMs: plan.holdMs, releaseMs: plan.releaseMs }, gestureTimeout(plan.totalMs, 300));
+    if (!result.success && result.error.code === "E_BAD_REQUEST" && /unknown (input )?op/.test(result.error.message)) {
+      gestureUnsupported = true;
+      return helperOutdated();
+    }
+    return result;
+  };
+  const fetchSnapshot = async (o) => {
+    const result = await request("snapshot", params({ interactiveOnly: o?.interactiveOnly, backend: o?.backend }));
+    if (!result.success)
+      return result;
+    const { fallback } = result.data;
+    if (fallback)
+      opts.log?.(`[ios] snapshot fell back ${fallback.from} -> ${fallback.to}: ${fallback.reason}`);
+    return { success: true, data: toSnapshot(result.data, now()) };
+  };
+  async function snapshot(o) {
+    const generation = swap.generation();
+    const first = await fetchSnapshot(o);
+    if (first.success) {
+      axFailures = 0;
+      return first;
+    }
+    if (first.error.code !== "E_AX_UNAVAILABLE") {
+      axFailures = 0;
+      return first;
+    }
+    axFailures += 1;
+    if (axFailures < 2)
+      return first;
+    opts.log?.("[ios] E_AX_UNAVAILABLE twice in a row: AX bridge looks stale, restarting warden-simd");
+    const restarted = await swap.restart(generation);
+    if (!restarted.success)
+      return restarted;
+    axFailures = 0;
+    return fetchSnapshot(o);
+  }
+  async function typeText(text) {
+    const typed = await sendVoid("typeText", { text }, typeTextBudgetMs(text));
+    if (typed.success || typed.error.code !== "E_UNSUPPORTED_TEXT")
+      return typed;
+    const rest = restOf(typed.error, text);
+    if (rest === undefined)
+      return typed;
+    const copied = await simctl.pbcopy(rest);
+    if (!copied.success)
+      return copied;
+    opts.log?.(`[ios] typeText: pasting ${rest.length} unmappable character(s)`);
+    return sendVoid("paste");
+  }
+  async function hashSettle(o) {
+    try {
+      const outcome = await settleByHash(async () => {
+        const snap = await snapshot();
+        if (!snap.success)
+          throw new DriverFailure(snap.error);
+        return snapshotHash(snap.data);
+      }, { quietMs: o.quietMs, timeoutMs: o.timeoutMs, now, sleep });
+      noteSpanDetail("via", "hash");
+      return { success: true, data: { ...outcome, via: "hash" } };
+    } catch (error) {
+      if (error instanceof DriverFailure)
+        return fail(error.error);
+      throw error;
+    }
+  }
+  async function rebind(bundleId) {
+    if (rebindUnsupported || settleUnsupported)
+      return false;
+    const reply = await request("rebind", { bundleId, rebindTimeoutMs: REBIND_TIMEOUT_MS }, { timeoutMs: REBIND_TIMEOUT_MS + SETTLE_MARGIN_MS });
+    if (!reply.success) {
+      if (reply.error.code === "E_UNSUPPORTED" || reply.error.code === "E_BAD_REQUEST")
+        rebindUnsupported = true;
+      noteSpanDetail("rebind", reply.error.code);
+      opts.log?.(`[ios] rebind after launch failed (${reply.error.code}): ${reply.error.message}`);
+      return false;
+    }
+    noteSpanDetail("rebind", reply.data.bound ? "bound" : reply.data.reason ?? "unbound");
+    noteSpanDetail("rebindMs", reply.data.waitedMs);
+    if (reply.data.restarts !== undefined && reply.data.restarts > 0)
+      noteSpanDetail("rebindRestarts", reply.data.restarts);
+    if (reply.data.recycled === true)
+      noteSpanDetail("rebindRecycled", true);
+    return reply.data.bound;
+  }
+  async function settle(o = {}) {
+    const quietMs = o.quietMs ?? DEFAULT_QUIET_MS;
+    const timeoutMs = o.timeoutMs ?? DEFAULT_SETTLE_TIMEOUT_MS2;
+    if (!settleUnsupported) {
+      const expected = launchedBundle;
+      const native = await request("settle", { quietMs, settleTimeoutMs: timeoutMs, ...expected === undefined ? {} : { bundleId: expected } }, { timeoutMs: timeoutMs + SETTLE_MARGIN_MS });
+      if (native.success) {
+        if (expected !== undefined && native.data.reason !== "frontmost_mismatch")
+          launchedBundle = undefined;
+        return { success: true, data: nativeDetail(native.data) };
+      }
+      if (native.error.code === "E_TIMEOUT") {
+        noteSpanDetail("reason", "helper_timeout");
+        return {
+          success: true,
+          data: { quiet: false, waitedMs: timeoutMs + SETTLE_MARGIN_MS, reason: "helper_timeout" }
+        };
+      }
+      if (native.error.code !== "E_UNSUPPORTED")
+        return native;
+      settleUnsupported = true;
+      opts.log?.("[ios] native settle unsupported, polling snapshot hashes");
+    }
+    return hashSettle({ quietMs, timeoutMs });
+  }
+  async function screenshot(o) {
+    const viaHelper = await request("screenshot", params({ path: o?.path, scale: o?.scale }));
+    if (viaHelper.success) {
+      const { path, png } = viaHelper.data;
+      if (o?.path)
+        return { success: true, data: { path: path ?? o.path } };
+      if (png !== undefined)
+        return { success: true, data: { png: decodeBase64(png) } };
+      if (path !== undefined)
+        return { success: true, data: { path } };
+      return fail(driverError("E_INTERNAL", "warden-simd screenshot returned neither path nor png"));
+    }
+    if (!SCREENSHOT_FALLBACK.has(viaHelper.error.code))
+      return viaHelper;
+    opts.log?.(`[ios] helper screenshot failed (${viaHelper.error.code}), using simctl io`);
+    return simctl.screenshot(o?.path);
+  }
+  function toAlertInfo(data) {
+    const { title, message, buttons } = data;
+    const info = { buttons: normalizeElements(buttons, client.ready.screen).elements };
+    if (title !== undefined)
+      info.title = title;
+    if (message !== undefined)
+      info.message = message;
+    return info;
+  }
+  async function readAlert(backend) {
+    const result = await request("alertButtons", params({ backend }));
+    if (!result.success)
+      return result;
+    return { success: true, data: result.data === null ? null : toAlertInfo(result.data) };
+  }
+  const alert = () => readAlert();
+  const alertOn = (backend) => readAlert(backend === "axbridge" && !bridgeUp ? "ax" : backend);
+  async function isFrontmost(bundleId) {
+    if (!bridgeUp)
+      return fail(driverError("E_UNSUPPORTED", "frontmost needs the axbridge backend"));
+    const result = await request("frontmost", { bundleId }, { timeoutMs: FRONTMOST_TIMEOUT_MS });
+    return result.success ? { success: true, data: result.data.frontmost } : result;
+  }
+  async function health() {
+    const result = await request("health");
+    if (!result.success)
+      return result;
+    const d = result.data;
+    return {
+      success: true,
+      data: {
+        platform: "ios",
+        id: udid,
+        version: d.version,
+        transport: d.hid.transport,
+        bridge: d.ax.bridge === "degraded" ? "available" : d.ax.bridge,
+        screen: d.screen,
+        detail: {
+          axDefault: d.ax.default,
+          ...d.ax.bridge === "degraded" ? { axBridge: "degraded" } : {},
+          ...d.ax.lastError ? { axLastError: d.ax.lastError } : {},
+          ...d.ax.error !== undefined ? { axError: d.ax.error } : {},
+          ...d.socket ? { socket: d.socket } : {},
+          ...d.xcode ? { xcode: d.xcode } : {},
+          ...d.state ? { state: d.state } : {}
+        }
+      }
+    };
+  }
+  async function orientation(set) {
+    const result = await request("orientation", params({ set }));
+    if (!result.success)
+      return result;
+    const { orientation: read, source } = result.data;
+    if (source !== undefined && source !== "device")
+      opts.log?.(`[ios] orientation ${read} is ${source}, not read from the device`);
+    if (read === "faceUp" || read === "faceDown" || read === "unknown") {
+      opts.log?.(`[ios] device reports ${read}; exposing it as portrait`);
+      return { success: true, data: "portrait" };
+    }
+    return { success: true, data: read };
+  }
+  async function pressButton(button) {
+    if (button === "back")
+      return fail(driverError("E_UNSUPPORTED", "iOS has no hardware back button"));
+    return sendVoid("pressButton", { button: BUTTONS[button] });
+  }
+  const driver = {
+    platform: "ios",
+    id: udid,
+    capabilities,
+    health,
+    snapshot,
+    async elementAtPoint(point, o) {
+      const result = await request("elementAtPoint", params({ x: point.x, y: point.y, reachability: o?.reachability }));
+      if (!result.success)
+        return result;
+      return {
+        success: true,
+        data: result.data === null ? null : normalizeElement(result.data, client.ready.screen)
+      };
+    },
+    tap: (point, o) => sendVoid("tap", params({ x: point.x, y: point.y, count: o?.count, durationMs: o?.durationMs })),
+    longPress: (point, o) => sendVoid("longPress", params({ x: point.x, y: point.y, durationMs: o?.durationMs }), gestureTimeout(o?.durationMs, 1000)),
+    swipe: (from, to, o) => sendVoid("swipe", params({ from, to, durationMs: o?.durationMs, momentum: o?.momentum }), gestureTimeout(o?.durationMs, 300)),
+    drag: (from, to, o) => sendVoid("drag", params({ from, to, pressMs: o?.pressMs, durationMs: o?.durationMs, releaseMs: o?.releaseMs }), gestureTimeout((o?.pressMs ?? 0) + (o?.durationMs ?? 0) + (o?.releaseMs ?? 0), 300)),
+    pinch: (center, scale, o) => sendVoid("pinch", params({ center, scale, durationMs: o?.durationMs, radius: o?.radius, angle: o?.angle }), gestureTimeout(o?.durationMs, 300)),
+    rotate: (center, degrees, o) => sendGesture(rotatePlan(center, degrees, o, DEFAULT_RADIUS)),
+    gesture: (paths, o) => sendGesture(planGesture(paths, o, 2)),
+    typeText,
+    key: (key, modifiers) => sendVoid("key", params({ usage: KEY_USAGE[key], modifiers: modifiers && [...modifiers] })),
+    selectAll: () => sendVoid("selectAll"),
+    pressButton,
+    screenshot,
+    orientation,
+    settle,
+    alert,
+    alertOn,
+    isFrontmost,
+    appearance: (set) => simctl.appearance(set),
+    async clipboard(set) {
+      if (set === undefined)
+        return simctl.pbpaste();
+      const copied = await simctl.pbcopy(set);
+      return copied.success ? { success: true, data: set } : copied;
+    },
+    app: {
+      launch: async (bundleId, o) => {
+        const launched = await simctl.launch(bundleId, o);
+        if (launched.success) {
+          launchedBundle = bundleId;
+          if (await rebind(bundleId))
+            launchedBundle = undefined;
+        }
+        return launched;
+      },
+      terminate: async (bundleId) => {
+        const terminated = await simctl.terminate(bundleId);
+        if (terminated.success && launchedBundle === bundleId)
+          launchedBundle = undefined;
+        return terminated;
+      },
+      openUrl: (url) => simctl.openUrl(url),
+      install: (path) => simctl.install(path),
+      uninstall: (bundleId) => simctl.uninstall(bundleId),
+      isInstalled: (bundleId) => simctl.isInstalled(bundleId),
+      isRunning: (bundleId) => simctl.isRunning(bundleId),
+      clearData: (bundleId, o) => simctl.clearData(bundleId, o)
+    },
+    close: () => client.close()
+  };
+  return driver;
+}
+var timeoutOption = (o) => o.defaultTimeoutMs ? { defaultTimeoutMs: o.defaultTimeoutMs } : {};
+async function trySocket(o, log) {
+  const socketPath = o.socketPath ?? o.env?.simdSocket;
+  if (!socketPath)
+    return;
+  const first = await connectSimd({ socketPath, log, ...timeoutOption(o) });
+  if (first.success)
+    return first.data;
+  if (!first.error.retryable) {
+    log(`[ios] WARNING: ${first.error.message}; spawning a helper on stdio instead`);
+    return;
+  }
+  log(`[ios] WARNING: ${first.error.message}; retrying once in ${SOCKET_RETRY_MS} ms`);
+  await (o.sleep ?? ((ms) => Bun.sleep(ms)))(SOCKET_RETRY_MS);
+  const second = await connectSimd({ socketPath, log, ...timeoutOption(o) });
+  if (second.success)
+    return second.data;
+  log(`[ios] WARNING: ${second.error.message}; spawning a helper on stdio instead (a live daemon on ${socketPath} would now share the simulator with it)`);
+  return;
+}
+async function connect(o, log) {
+  const socket = await trySocket(o, log);
+  if (socket)
+    return { success: true, data: socket };
+  const helper = resolveHelper(o);
+  if (!helper.success)
+    return helper;
+  const resources = join6(dirname4(helper.data), "Resources");
+  return spawnSimd({
+    helperPath: helper.data,
+    udid: o.udid,
+    log,
+    ...(o.exists ?? existsSync2)(resources) ? { resources } : {},
+    ...o.spawn ? { spawn: o.spawn } : {},
+    ...timeoutOption(o)
+  });
+}
+async function openIosDriver(o) {
+  const log = o.log ?? (() => {
+    return;
+  });
+  const now = o.now ?? Date.now;
+  const exec = o.debug ? timedExec(o.exec, log, now) : o.exec;
+  const simctl = createSimctl({ udid: o.udid, exec, ...o.devicesRoot ? { devicesRoot: o.devicesRoot } : {} });
+  if (!o.client && !(o.socketPath ?? o.env?.simdSocket)) {
+    const helper = resolveHelper(o);
+    if (!helper.success)
+      return helper;
+  }
+  const connecting = o.client ? Promise.resolve({ success: true, data: o.client }) : connect(o, log);
+  const [client, automation] = await Promise.all([connecting, simctl.enableAutomation()]);
+  if (!automation.success)
+    log(`[ios] could not enable AX automation: ${automation.error.message}`);
+  if (!client.success)
+    return client;
+  const swap = swappableClient(client.data, {
+    now,
+    log,
+    reopen: () => connect(o, log),
+    ...o.debug ? { debug: true } : {}
+  });
+  return {
+    success: true,
+    data: createIosDriver(swap, simctl, { udid: o.udid, now, sleep: o.sleep ?? ((ms) => Bun.sleep(ms)), log })
+  };
+}
+function timedExec(exec, log, now) {
+  return async (cmd, opts) => {
+    const started = now();
+    const res = await exec(cmd, opts);
+    const label = cmd[0] === "sh" ? "sh (pbcopy)" : cmd.slice(0, 3).join(" ");
+    log(`[ios] exec ${label} ${Math.round(now() - started)} ms (exit ${res.exitCode})`);
+    return res;
+  };
+}
+
+// ../../packages/e2e/src/driver/open.ts
+var DEBUG_ENV = "WARDEN_E2E_DEBUG";
+var stderrLog = (line) => {
+  process.stderr.write(`${line}
+`);
+};
+function androidOptions(env, deps, debug) {
+  const android = deps.android ?? {};
+  const log = deps.log ?? (debug ? stderrLog : undefined);
+  return {
+    ...android,
+    serial: env.udid,
+    adb: android.adb ?? androidTools(process.env).adb,
+    exec: deps.exec ?? bunExec,
+    appPackage: android.appPackage ?? env.bundleId,
+    ...android.uiad === undefined && android.spawn === undefined ? { uiad: uiadFromEnv(process.env) } : {},
+    state: android.state ?? createAndroidStateStore({
+      dir: androidStateDir(deps.wardenHome ?? wardenHome(process.env)),
+      ...log ? { log } : {}
+    }),
+    ...log ? { log } : {}
+  };
+}
+async function openDriver(env, deps = {}) {
+  const debug = deps.debug ?? process.env[DEBUG_ENV] === "1";
+  switch (env.platform) {
+    case "ios":
+      return openIosDriver({
+        ...deps,
+        udid: env.udid,
+        env,
+        exec: deps.exec ?? bunExec,
+        debug,
+        ...deps.log ? {} : debug ? { log: stderrLog } : {}
+      });
+    case "android":
+      return openAndroidDriver(androidOptions(env, deps, debug));
+  }
+}
+var defaultDriverFactory = (env) => openDriver(env);
+
+// ../../packages/e2e/src/driver/unwrap.ts
+var TIMEOUTS = new Set(["E_TIMEOUT", "E_APP_NOT_RESPONDING"]);
+var INFRASTRUCTURE = new Set([
+  "E_HELPER_MISSING",
+  "E_HELPER_CRASHED",
+  "E_NOT_BOOTED",
+  "E_UNKNOWN_DEVICE",
+  "E_AX_UNAVAILABLE",
+  "E_APP_UNAVAILABLE",
+  "E_INTERNAL"
+]);
+function codeFor(code) {
+  if (TIMEOUTS.has(code))
+    return "TIMEOUT";
+  if (INFRASTRUCTURE.has(code))
+    return "DRIVER";
+  return "ACTION_FAILED";
+}
+function toE2eError(error, action) {
+  return new E2eError2(codeFor(error.code), `${action} failed: ${error.code}: ${error.message}`);
+}
+function aborted(action, signal) {
+  const reason = signal.reason;
+  const detail = reason instanceof Error ? `: ${reason.message}` : "";
+  return new E2eError2("TIMEOUT", `${action} aborted (test deadline reached or cancelled)${detail}`);
+}
+async function settled(call, action, signal) {
+  if (signal === undefined)
+    return call();
+  if (signal.aborted)
+    throw aborted(action, signal);
+  let onAbort;
+  const abort = new Promise((_, reject) => {
+    onAbort = () => reject(aborted(action, signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([call(), abort]);
+  } finally {
+    if (onAbort !== undefined)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+async function unwrap(call, action, signal) {
+  const result = await settled(call, action, signal);
+  if (!result.success)
+    throw toE2eError(result.error, action);
+  return result.data;
+}
+
+// ../../packages/e2e/src/fixture-session.ts
+var systemClock = {
+  now: () => Date.now(),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+};
+
+// ../../packages/e2e/src/app.ts
+var CONTENT_POLL_MS = [100, 200, 400];
+var DECOR_IDS = new Set([
+  "content",
+  "action_bar_root",
+  "action_bar_container",
+  "action_bar",
+  "decor_content_parent",
+  "statusBarBackground",
+  "navigationBarBackground",
+  "splashscreen_view",
+  "splashscreen_icon_view",
+  "splashscreen_branding_view"
+]);
+function isContent(element, parent, platform) {
+  if (element.hidden === true)
+    return false;
+  const id = element.identifier;
+  if (id !== undefined && id !== "" && !(platform === "android" && DECOR_IDS.has(id)))
+    return true;
+  return isInteractiveRole(resolveRole(element, parent).role);
+}
+function hasContent(snapshot) {
+  const visit = (element, parent) => isContent(element, parent, snapshot.platform) || element.children.some((child) => visit(child, element));
+  return snapshot.elements.some((element) => visit(element, undefined));
+}
+function parseWait(wait) {
+  if (wait === undefined || wait === "none")
+    return { kind: "none" };
+  if (wait === "quiet")
+    return { kind: "quiet" };
+  if (typeof wait === "object" && wait !== null && isLocator(wait.until)) {
+    const { timeout } = wait;
+    if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
+      throw new E2eError2("INVALID_ARGUMENT", `app.open wait timeout must be a non-negative number, got ${timeout}`);
+    }
+    return timeout === undefined ? { kind: "until", until: wait.until } : { kind: "until", until: wait.until, timeout };
+  }
+  throw new E2eError2("INVALID_ARGUMENT", `app.open wait must be "quiet", "none" or { until: <locator made by screen> }, got ${describeWait(wait)}`);
+}
+function describeWait(wait) {
+  if (typeof wait === "string")
+    return JSON.stringify(wait);
+  if (wait === null || typeof wait !== "object")
+    return String(wait);
+  return `{ ${Object.keys(wait).join(", ")} }`;
+}
+var stderrLog2 = (line) => {
+  process.stderr.write(`${line}
+`);
+};
+function createApp({ session, driver, env, log = stderrLog2, clock = systemClock }) {
+  const bundleId = env.bundleId;
+  let droppedLogged = false;
+  const envLaunchArgs = () => {
+    if (driver.platform !== "android" || env.launchArgs.length === 0)
+      return env.launchArgs;
+    if (!droppedLogged) {
+      droppedLogged = true;
+      log(`[warden-e2e] Android launch takes no args: ignoring WARDEN_LAUNCH_ARGS ${JSON.stringify(env.launchArgs)}`);
+    }
+    return [];
+  };
+  const look = async () => {
+    const read = await settled(() => canObserve(driver) ? driver.observe({ reuse: false }) : driver.snapshot(), `read ${bundleId}`, session.signal);
+    return read.success ? read.data : undefined;
+  };
+  const waitForContent = async () => {
+    const deadline = clock.now() + DEFAULT_SETTLE_TIMEOUT_MS;
+    for (let poll = 0;; poll++) {
+      const snapshot = await look();
+      if (snapshot !== undefined && hasContent(snapshot))
+        return;
+      const left = deadline - clock.now();
+      if (left <= 0)
+        return;
+      const gap = CONTENT_POLL_MS[Math.min(poll, CONTENT_POLL_MS.length - 1)] ?? 100;
+      await clock.sleep(Math.min(gap, left));
+    }
+  };
+  const waitUntilQuiet = async () => {
+    const quiet = await settled(() => driver.settle({ quietMs: DEFAULT_SETTLE_QUIET_MS, timeoutMs: DEFAULT_SETTLE_TIMEOUT_MS }), `wait for ${bundleId}`, session.signal);
+    if (!quiet.success && quiet.error.code !== "E_UNSUPPORTED")
+      throw toE2eError(quiet.error, `wait for ${bundleId}`);
+  };
+  const launch = async (options = {}) => {
+    const wait = parseWait(options.wait);
+    const opts = {
+      args: [...envLaunchArgs(), ...options.args ?? []],
+      relaunch: true
+    };
+    if (options.env !== undefined)
+      opts.env = options.env;
+    await unwrap(() => driver.app.launch(bundleId, opts), `launch ${bundleId}`, session.signal);
+    if (options.url !== undefined) {
+      const url = options.url;
+      await unwrap(() => driver.app.openUrl(url), `open ${url}`, session.signal);
+    }
+    if (wait.kind === "quiet") {
+      await waitForContent();
+      await waitUntilQuiet();
+    }
+    if (wait.kind === "until") {
+      await wait.until.waitFor({ state: "visible", timeout: wait.timeout ?? env.assertionTimeoutMs });
+      await waitUntilQuiet();
+    }
+  };
+  const terminate = () => unwrap(() => driver.app.terminate(bundleId), `terminate ${bundleId}`, session.signal);
+  return {
+    open: launch,
+    close: terminate,
+    async restart() {
+      await launch();
+    },
+    async reinstall() {
+      const path = env.appPath;
+      if (path === undefined) {
+        throw new E2eError2("INVALID_ARGUMENT", "app.reinstall() needs WARDEN_APP_PATH (the build to install) to be set");
+      }
+      const installed = await unwrap(() => driver.app.isInstalled(bundleId), `check ${bundleId}`, session.signal);
+      if (installed)
+        await unwrap(() => driver.app.uninstall(bundleId), `uninstall ${bundleId}`, session.signal);
+      await unwrap(() => driver.app.install(path), `install ${path}`, session.signal);
+    },
+    async clearData() {
+      await unwrap(() => driver.app.clearData(bundleId, { keychain: true }), `clear data ${bundleId}`, session.signal);
+    },
+    isRunning() {
+      return unwrap(() => driver.app.isRunning(bundleId), `check ${bundleId} running`, session.signal);
+    }
+  };
+}
+
+// ../../packages/e2e/src/device.ts
+import { mkdirSync, readdirSync, writeFileSync } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
+
+// ../../packages/e2e/src/driver/alerts.ts
+function canReadAlertOn(driver) {
+  return typeof driver.alertOn === "function";
+}
+function canProbeFrontmost(driver) {
+  return typeof driver.isFrontmost === "function";
+}
+
+// ../../packages/e2e/src/alert-reader.ts
+var ALERT_READ_ATTEMPTS = 13;
+var ALERT_READ_RETRY_MS = 100;
+var ALERT_MODAL_LOOKS = 3;
+var ALERT_MODAL_RETRY_MS = 200;
+function createAlertReader({ driver, clock, signal }) {
+  const read = (backend) => settled(() => backend !== undefined && canReadAlertOn(driver) ? driver.alertOn(backend) : driver.alert(), "read alert", signal());
+  const readOne = async (backend, modalLooks) => {
+    for (let looked = 0;; looked += 1) {
+      const result = await read(backend);
+      if (!result.success)
+        return result;
+      const info = result.data;
+      if (info === null || info.buttons.length > 0 || looked >= modalLooks)
+        return result;
+      await clock.sleep(ALERT_MODAL_RETRY_MS);
+    }
+  };
+  const readBoth = async () => {
+    for (let failures = 1;; failures += 1) {
+      const result = await read();
+      if (result.success)
+        return result.data;
+      if (!result.error.retryable || failures >= ALERT_READ_ATTEMPTS)
+        throw toE2eError(result.error, "read alert");
+      await clock.sleep(ALERT_READ_RETRY_MS);
+    }
+  };
+  return async (backend, modalLooks = ALERT_MODAL_LOOKS) => {
+    if (backend !== undefined && canReadAlertOn(driver)) {
+      const one = await readOne(backend, modalLooks);
+      if (one.success)
+        return one.data;
+      if (backend === "axbridge") {
+        const host = await readOne("ax", 0);
+        if (host.success)
+          return host.data;
+      }
+    }
+    return readBoth();
+  };
+}
+
+// ../../packages/e2e/src/device-devtools.ts
+function createDeviceDevtools(source) {
+  const connect = async () => {
+    const attached = await source.devtools();
+    if (attached.success)
+      return attached.data;
+    throw new E2eError2("SESSION", `devtools unavailable: ${attached.error.message}`);
+  };
+  const attach = () => source.devtools();
+  return {
+    async evaluate(expression, options) {
+      const attached = await attach();
+      if (!attached.success)
+        return { success: false, error: attached.error };
+      return attached.data.evaluate(expression, options);
+    },
+    async reloadJs() {
+      const attached = await attach();
+      return attached.success ? attached.data.reloadJs() : attached;
+    },
+    async tree(options) {
+      const attached = await attach();
+      return attached.success ? attached.data.tree(options) : attached;
+    },
+    network: {
+      async entries(query) {
+        return (await connect()).network.entries(query);
+      },
+      async clear() {
+        await (await connect()).network.clear();
+      }
+    },
+    console: {
+      async lines() {
+        return (await connect()).console.lines();
+      },
+      async clear() {
+        (await connect()).console.clear();
+      },
+      async mark(label) {
+        (await connect()).console.mark(label);
+      }
+    },
+    connect
+  };
+}
+
+// ../../packages/e2e/src/device-link.ts
+var OPEN_LINK_WAIT_MS = 8000;
+var FAST_POLL_MS = 100;
+var FAST_WINDOW_MS = 1000;
+var SLOW_POLL_MS = 250;
+var QUIET_MS = 1200;
+var MAX_PRESSES = 3;
+var SHEET_SETTLE_MS = 500;
+var PRESS_GAP_MS = 600;
+var sheetlessLinks = new WeakMap;
+function sheetlessFor(session) {
+  const known = sheetlessLinks.get(session) ?? new Set;
+  sheetlessLinks.set(session, known);
+  return known;
+}
+var linksInFlight = new WeakMap;
+function linkInFlight(session) {
+  return (linksInFlight.get(session) ?? 0) > 0;
+}
+async function whileLinkInFlight(session, fn) {
+  linksInFlight.set(session, (linksInFlight.get(session) ?? 0) + 1);
+  try {
+    return await fn();
+  } finally {
+    linksInFlight.set(session, (linksInFlight.get(session) ?? 1) - 1);
+  }
+}
+function isOpenInSheet(info) {
+  return info.title !== undefined && /^open in\b/i.test(info.title.trim());
+}
+function linkKey(url) {
+  const trimmed = url.trim();
+  const web = /^(https?):\/\/([^/?#]+)/i.exec(trimmed);
+  if (web !== null)
+    return `${web[1]?.toLowerCase()}://${web[2]?.toLowerCase()}`;
+  return /^([a-z][a-z0-9+.-]*):/i.exec(trimmed)?.[1]?.toLowerCase() ?? "";
+}
+var NOT_LOOKING = { sheetUp: false, confirmed: false, finished: false };
+async function lookForSheet(deps, plan, watch, started, remembered) {
+  const { clock } = deps;
+  if (!watch.looking)
+    return NOT_LOOKING;
+  if (remembered && clock.now() - started < QUIET_MS)
+    return { sheetUp: false, confirmed: true, finished: false };
+  const cheap = clock.now() - watch.lastSheetAt < QUIET_MS;
+  const info = await deps.readAlert(cheap ? "ax" : undefined, 0);
+  const open = info === null ? undefined : findButton(info.buttons, "Open");
+  if (open === undefined) {
+    if (watch.presses > 0)
+      watch.looking = false;
+    watch.sheetSeenAt = undefined;
+    return { sheetUp: false, confirmed: !cheap, finished: false };
+  }
+  const now = clock.now();
+  watch.lastSheetAt = now;
+  watch.sheetSeenAt ??= now;
+  const since = (at) => at === undefined ? Number.POSITIVE_INFINITY : now - at;
+  const settled = since(watch.sheetSeenAt) >= SHEET_SETTLE_MS && since(watch.lastPressAt) >= PRESS_GAP_MS;
+  if (!settled)
+    return { sheetUp: true, confirmed: false, finished: false };
+  if (watch.presses >= MAX_PRESSES)
+    return { sheetUp: true, confirmed: false, finished: plan.until === undefined };
+  await deps.press(open);
+  watch.presses += 1;
+  watch.lastPressAt = clock.now();
+  return { sheetUp: true, confirmed: false, finished: false };
+}
+async function handedOver(deps, watch, look, remembered) {
+  if (!watch.looking || !look.confirmed)
+    return false;
+  if (deps.clock.now() - watch.lastSheetAt < (remembered ? 0 : QUIET_MS))
+    return false;
+  return await deps.appInFront() === true;
+}
+async function reachedTarget(deps, plan, watch, look) {
+  if (plan.until === undefined)
+    return !watch.looking;
+  return !look.sheetUp && await deps.isVisible(plan.until);
+}
+function nextPollMs(sinceSheet) {
+  const poll = sinceSheet < FAST_WINDOW_MS ? FAST_POLL_MS : SLOW_POLL_MS;
+  const untilQuiet = QUIET_MS - sinceSheet;
+  return untilQuiet > 0 ? Math.min(poll, untilQuiet) : poll;
+}
+async function waitForLink(deps, plan) {
+  const { clock, sheetless } = deps;
+  const started = clock.now();
+  const deadline = started + plan.waitMs;
+  const remembered = plan.answersSheet && sheetless.has(plan.key);
+  const watch = {
+    looking: plan.answersSheet,
+    presses: 0,
+    sheetSeenAt: undefined,
+    lastPressAt: undefined,
+    lastSheetAt: started
+  };
+  for (;; ) {
+    const look = await lookForSheet(deps, plan, watch, started, remembered);
+    if (look.finished || await reachedTarget(deps, plan, watch, look) || clock.now() >= deadline)
+      return;
+    if (await handedOver(deps, watch, look, remembered)) {
+      sheetless.add(plan.key);
+      if (plan.until === undefined)
+        return;
+      watch.looking = false;
+    }
+    await clock.sleep(nextPollMs(clock.now() - watch.lastSheetAt));
+  }
+}
+
+// ../../packages/e2e/src/device.ts
+function nextShotNumber(dir, issued) {
+  let highest = issued.get(dir) ?? 0;
+  try {
+    for (const file of readdirSync(join7(dir, "screenshots"))) {
+      const n = /^(\d{3})-/.exec(file)?.[1];
+      if (n !== undefined)
+        highest = Math.max(highest, Number(n));
+    }
+  } catch {}
+  return highest + 1;
+}
+function androidButton(buttons, ids) {
+  for (const id of ids) {
+    const found = buttons.find((button) => button.identifier === id);
+    if (found !== undefined)
+      return found;
+  }
+  return;
+}
+function alertTarget(info, action, platform) {
+  const { buttons } = info;
+  if (action === "accept") {
+    if (platform !== "android")
+      return firstOf(buttons, ACCEPT_BUTTONS) ?? buttons[buttons.length - 1];
+    return androidButton(buttons, ANDROID_PERMISSION_ALLOW_IDS) ?? firstOf(buttons, ACCEPT_BUTTONS) ?? androidButton(buttons, [ANDROID_POSITIVE_ID]) ?? buttons[buttons.length - 1];
+  }
+  if (action === "dismiss" && isOpenInSheet(info))
+    return findButton(buttons, "Open");
+  if (action === "dismiss") {
+    if (platform !== "android")
+      return firstOf(buttons, DISMISS_BUTTONS) ?? buttons[0];
+    return androidButton(buttons, ANDROID_PERMISSION_DENY_IDS) ?? firstOf(buttons, DISMISS_BUTTONS) ?? androidButton(buttons, [ANDROID_NEGATIVE_ID]) ?? buttons[0];
+  }
+  const target = findButton(buttons, action.button);
+  if (target === undefined) {
+    const names = buttons.map((b) => nameOf(b) ?? "?").join(", ");
+    throw new E2eError2("ACTION_FAILED", `alert has no "${action.button}" button (buttons: ${names})`);
+  }
+  return target;
+}
+function createDevice({ session, driver, env, clock = systemClock, perfExec }) {
+  const issued = new Map;
+  const signal = () => session.signal;
+  const pressAlertButton = async (button, action) => {
+    await unwrap(() => driver.tap(centre(button)), action, signal());
+  };
+  const readAlert = createAlertReader({ driver, clock, signal });
+  const appInFront = async () => {
+    if (env.bundleId === "" || !canProbeFrontmost(driver))
+      return;
+    const result = await settled(() => driver.isFrontmost(env.bundleId), "probe frontmost app", signal());
+    return result.success ? result.data : undefined;
+  };
+  const isVisible = async (locator) => {
+    try {
+      return await locator.isVisible();
+    } catch (error) {
+      if (signal()?.aborted)
+        throw error;
+      return false;
+    }
+  };
+  const readSnapshot = (opts) => unwrap(() => driver.snapshot(opts), "snapshot", signal());
+  const { devtools: attach, peekDevtools } = session;
+  let devtools;
+  const lazyDevtools = () => {
+    if (env.metroUrl === undefined || attach === undefined || peekDevtools === undefined)
+      return;
+    if (devtools === undefined) {
+      devtools = createDeviceDevtools({
+        devtools: () => attach.call(session),
+        peekDevtools: () => peekDevtools.call(session)
+      });
+      attach.call(session);
+    }
+    return devtools;
+  };
+  const perf = createDevicePerf({
+    exec: perfExec ?? spawnWarden(env.wardenBin),
+    udid: env.udid,
+    budgets: parseBudgets(env.perfBudgets),
+    attemptDir: () => session.attemptDir,
+    addFile: (relative) => session.attempt?.files.add(relative),
+    ...env.wardenBin === undefined && perfExec === undefined ? { unavailable: "WARDEN_BIN is not set (run the spec with `warden e2e`)" } : {}
+  });
+  const device = {
+    get devtools() {
+      return lazyDevtools();
+    },
+    perf,
+    async alert(action) {
+      const info = await readAlert("axbridge");
+      if (info === null || info.buttons.length === 0)
+        return false;
+      if (isOpenInSheet(info) && typeof action === "string" && linkInFlight(session))
+        return false;
+      const target = alertTarget(info, action, driver.platform);
+      if (target === undefined)
+        return false;
+      await pressAlertButton(target, "press alert button");
+      return true;
+    },
+    async openLink(url, options = {}) {
+      const waitMs = options.waitMs ?? OPEN_LINK_WAIT_MS;
+      if (!Number.isFinite(waitMs) || waitMs < 0) {
+        throw new E2eError2("INVALID_ARGUMENT", `openLink waitMs must be a non-negative number, got ${String(waitMs)}`);
+      }
+      await unwrap(() => driver.app.openUrl(url), `open ${url}`, signal());
+      const answersSheet = options.accept !== false && driver.platform === "ios" && driver.capabilities.alerts;
+      if (!answersSheet && options.until === undefined)
+        return;
+      await whileLinkInFlight(session, () => waitForLink({
+        clock,
+        readAlert,
+        press: (button) => pressAlertButton(button, "accept open-in sheet"),
+        appInFront,
+        isVisible,
+        sheetless: sheetlessFor(session)
+      }, { key: linkKey(url), answersSheet, waitMs, ...options.until === undefined ? {} : { until: options.until } }));
+    },
+    async home() {
+      await unwrap(() => driver.pressButton("home"), "press home", signal());
+    },
+    async back() {
+      if (driver.platform === "ios") {
+        throw new E2eError2("INVALID_ARGUMENT", "device.back() is Android only: iOS has no back key");
+      }
+      await unwrap(() => driver.pressButton("back"), "press back", signal());
+    },
+    orientation(set) {
+      return unwrap(() => driver.orientation(set), "orientation", signal());
+    },
+    appearance(set) {
+      return unwrap(() => driver.appearance(set), "appearance", signal());
+    },
+    clipboard() {
+      return unwrap(() => driver.clipboard(), "read clipboard", signal());
+    },
+    async setClipboard(text) {
+      await unwrap(() => driver.clipboard(text), "set clipboard", signal());
+    },
+    async hideKeyboard() {
+      const snapshot = await readSnapshot();
+      if (!snapshot.flat.some((element) => element.role === "keyboard"))
+        return;
+      if (driver.platform === "ios")
+        await unwrap(() => driver.key("Enter"), "hide keyboard", signal());
+      else
+        await unwrap(() => driver.pressButton("back"), "hide keyboard", signal());
+    },
+    async screenshot(name) {
+      const dir = session.attemptDir ?? join7(session.out, "adhoc");
+      const n = nextShotNumber(dir, issued);
+      issued.set(dir, n);
+      const path = screenshotPath(dir, n, name);
+      mkdirSync(dirname5(path), { recursive: true });
+      const shot = await unwrap(() => driver.screenshot({ path }), "screenshot", signal());
+      if (shot.path === undefined && shot.png !== undefined)
+        writeFileSync(path, shot.png);
+      session.trace?.write({ type: "screenshot", ts: clock.now(), kind: "device", label: name, path });
+      return path;
+    },
+    async snapshot(options = {}) {
+      const interactiveOnly = options.interactiveOnly ?? false;
+      const snapshot = await readSnapshot({ interactiveOnly });
+      const rendered = renderSnapshot(snapshot, { interactiveOnly, refs: new Map });
+      return [renderHeader({ snapshot, rendered, interactiveOnly }), ...rendered.lines].join(`
+`);
+    },
+    async settle(options = {}) {
+      const quietMs = options.quietMs ?? DEFAULT_SETTLE_QUIET_MS;
+      const timeoutMs = options.timeout ?? DEFAULT_SETTLE_TIMEOUT_MS;
+      const native = await settled(() => driver.settle({ quietMs, timeoutMs }), "settle", signal());
+      if (native.success)
+        return settleDetailOf(native.data);
+      if (native.error.code !== "E_UNSUPPORTED")
+        throw toE2eError(native.error, "settle");
+      const polled = await settleByHash(async () => snapshotHash(await readSnapshot()), {
+        quietMs,
+        timeoutMs,
+        now: clock.now,
+        sleep: clock.sleep
+      });
+      return { ...polled, via: "hash" };
+    }
+  };
+  return device;
+}
+
+// ../../packages/e2e/src/screen/poll.ts
+var systemClock2 = {
+  now: () => Date.now(),
+  sleep(ms, signal) {
+    return new Promise((resolve) => {
+      if (signal?.aborted)
+        return resolve();
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+};
+var DEFAULT_POLL_INTERVAL_MS = 100;
+var DEFAULT_POLL_SCHEDULE = {
+  fastMs: DEFAULT_POLL_INTERVAL_MS,
+  fastForMs: 1000,
+  slowMs: 250
+};
+async function poll(step, options) {
+  const now = options.now ?? systemClock2.now;
+  const sleep = options.sleep ?? systemClock2.sleep;
+  const schedule = options.schedule ?? DEFAULT_POLL_SCHEDULE;
+  const startedAt = now();
+  const deadline = startedAt + options.timeoutMs;
+  const gap = (at) => options.intervalMs ?? (at - startedAt < schedule.fastForMs ? schedule.fastMs : schedule.slowMs);
+  let attempts = 0;
+  let last;
+  for (;; ) {
+    if (options.signal?.aborted)
+      return { status: "aborted", attempts };
+    attempts += 1;
+    const outcome = await step(attempts);
+    if (outcome.done)
+      return { status: "done", value: outcome.value, attempts };
+    last = outcome.state;
+    const at = now();
+    const remaining = deadline - at;
+    if (remaining <= 0)
+      return { status: "timeout", last, attempts };
+    const wanted = Math.min(gap(at), outcome.maxWaitMs === undefined ? Number.POSITIVE_INFINITY : outcome.maxWaitMs);
+    await sleep(Math.max(0, Math.min(wanted, remaining)), options.signal);
+  }
+}
+
+// ../../packages/e2e/src/screen/context.ts
+var EXCERPT_LINES = 40;
+var MAX_ALERT_ANSWERS = 3;
+var REACT_THROTTLE_MS = 450;
+var REACT_TIMEOUT_MS = 2000;
+
+class Runtime {
+  host;
+  reactCache;
+  indexed = new WeakMap;
+  constructor(host) {
+    this.host = host;
+  }
+  get clock() {
+    return this.host.clock ?? systemClock2;
+  }
+  actionTimeout() {
+    return this.host.actionTimeout?.() ?? this.host.env.actionTimeoutMs;
+  }
+  assertionTimeout() {
+    return this.host.assertionTimeout?.() ?? this.host.env.assertionTimeoutMs ?? DEFAULT_ASSERTION_TIMEOUT_MS;
+  }
+  budget(timeoutMs) {
+    const total = timeoutMs ?? this.actionTimeout();
+    const deadline = this.clock.now() + total;
+    return { remaining: () => Math.max(0, deadline - this.clock.now()), total };
+  }
+  step(label, fn) {
+    return this.host.step === undefined ? fn() : this.host.step(label, fn);
+  }
+  span(op, fn, options) {
+    return this.host.span === undefined ? fn() : this.host.span(op, fn, options);
+  }
+  indexOf(snapshot) {
+    const known = this.indexed.get(snapshot);
+    if (known !== undefined)
+      return known;
+    const index = indexSnapshot(snapshot);
+    this.indexed.set(snapshot, index);
+    return index;
+  }
+  async tryObserve(options = {}) {
+    const driver = await this.host.driver();
+    let reuse = options.reuse === true;
+    for (let answered = 0;; answered += 1) {
+      const before = options.withPrevious === true && canObserve(driver) ? driver.previous?.() : undefined;
+      const result = canObserve(driver) ? await driver.observe({ reuse }) : await driver.snapshot();
+      if (!result.success)
+        return { ok: false, error: result.error };
+      const observation = {
+        ok: true,
+        observed: { driver, snapshot: result.data, index: this.indexOf(result.data) }
+      };
+      if (before !== undefined)
+        observation.earlier = this.earlierThan(driver, before, result.data);
+      if (options.alerts === false || answered >= MAX_ALERT_ANSWERS)
+        return observation;
+      if (!await this.answeredAlert(driver, result.data))
+        return observation;
+      reuse = false;
+    }
+  }
+  earlierThan(driver, before, look) {
+    const after = canObserve(driver) ? driver.previous?.() : undefined;
+    const same = after !== undefined && after.generation === before.generation && after.snapshot === look;
+    const earlier = same && before.snapshot !== look ? before.snapshot : undefined;
+    return {
+      previous: earlier === undefined ? undefined : { driver, snapshot: earlier, index: this.indexOf(earlier) },
+      sinceInputMs: before.sinceInputMs
+    };
+  }
+  async answeredAlert(driver, snapshot) {
+    const answer = this.host.answerSystemAlert;
+    if (answer === undefined)
+      return false;
+    const shown = snapshot.modal !== undefined || canDetectAlerts(driver) && driver.alertIn(snapshot) !== null;
+    return shown && await answer();
+  }
+  async forgetObservation() {
+    const driver = await this.host.driver();
+    if (canObserve(driver))
+      driver.invalidateObservations();
+  }
+  async observe(options = {}) {
+    const reuse = options.reuse ?? true;
+    const result = await this.poll(async (attempt) => {
+      const observation = await this.tryObserve({ reuse: reuse && attempt === 1 });
+      if (observation.ok)
+        return { done: true, value: observation.observed };
+      if (!observation.error.retryable)
+        throw driverFailure("snapshot", observation.error);
+      return { done: false, state: observation.error };
+    }, this.actionTimeout());
+    if (result.status === "done")
+      return result.value;
+    throw driverFailure("snapshot", result.last ?? { code: "E_TIMEOUT", message: "no snapshot", retryable: true });
+  }
+  async reactMatches(testId, observed) {
+    const facet = this.host.devtools?.();
+    if (facet === undefined)
+      return [];
+    const key = typeof testId === "string" ? `s:${testId}` : `r:${testId.toString()}`;
+    const cached = this.reactCache;
+    if (cached !== undefined && cached.key === key && this.clock.now() - cached.at < REACT_THROTTLE_MS) {
+      return cached.matches;
+    }
+    const view = { platform: observed.snapshot.platform, screen: observed.snapshot.screen };
+    const matches = await locateByTestIdViaReact(facet, testId, view, { timeoutMs: REACT_TIMEOUT_MS });
+    this.reactCache = { key, at: this.clock.now(), matches };
+    return matches;
+  }
+  excerpt(snapshot) {
+    const rendered = renderSnapshot(snapshot, { interactiveOnly: true, refs: new Map, maxLines: EXCERPT_LINES });
+    return [renderHeader({ snapshot, rendered, interactiveOnly: true }), ...rendered.lines].join(`
+`);
+  }
+  async poll(step, timeoutMs, options = {}) {
+    const signal = this.host.signal;
+    const result = await poll(step, {
+      timeoutMs,
+      ...options.intervalMs === undefined ? {} : { intervalMs: options.intervalMs },
+      ...signal === undefined ? {} : { signal },
+      now: this.clock.now,
+      sleep: this.clock.sleep
+    });
+    if (result.status === "aborted")
+      throw abortError(signal);
+    return result;
+  }
+  drive(verb, result) {
+    if (!result.success)
+      throw driverFailure(verb, result.error, "ACTION_FAILED");
+    return result.data;
+  }
+}
+function driverFailure(verb, error, code = "DRIVER") {
+  return new E2eError2(code, `${verb} failed: ${error.code}: ${error.message}`);
+}
+function abortError(signal) {
+  const reason = signal?.reason;
+  if (reason instanceof E2eError2)
+    return reason;
+  return new E2eError2("TIMEOUT", "the test was aborted before the action finished");
+}
+
+// ../../packages/e2e/src/screen/screen.ts
+function isFinitePoint(point) {
+  return Number.isFinite(point.x) && Number.isFinite(point.y);
+}
+function createScreen(host) {
+  const rt = new Runtime(host);
+  const lazy = (query) => new Locator({ kind: "query", query }, rt);
+  const swipe = async (options) => {
+    const keys = Object.keys(options);
+    const allowed = "direction" in options ? ["direction", "momentum"] : ["from", "to", "durationMs"];
+    const unknown = keys.filter((key) => !allowed.includes(key));
+    if (unknown.length > 0 || keys.length === 0 || "direction" in options && "from" in options) {
+      throw new E2eError2("INVALID_ARGUMENT", "swipe takes either { direction, momentum? } or { from, to, durationMs? }, not a mix");
+    }
+    return rt.step("swipe", async () => {
+      if ("direction" in options) {
+        const observed = await rt.observe();
+        const vector = swipeVector(options.direction, screenRect(observed.snapshot.screen), options.momentum);
+        rt.drive("swipe", await observed.driver.swipe(vector.from, vector.to, vector.options));
+        return;
+      }
+      if (!isFinitePoint(options.from) || !isFinitePoint(options.to)) {
+        throw new E2eError2("INVALID_ARGUMENT", "swipe needs finite coordinates for from and to");
+      }
+      const driver = await host.driver();
+      const opts = options.durationMs === undefined ? undefined : { durationMs: options.durationMs };
+      rt.drive("swipe", await driver.swipe(options.from, options.to, opts));
+    });
+  };
+  return {
+    getByTestId: (id, options) => lazy(testIdQuery(id, options)),
+    getByText: (text, options) => lazy(textQuery("text", text, options)),
+    getByLabel: (text, options) => lazy(textQuery("label", text, options)),
+    getByPlaceholder: (text, options) => lazy(textQuery("placeholder", text, options)),
+    getByValue: (value, options) => lazy(textQuery("value", value, options)),
+    getByRole: (role, nameOrOptions, options) => lazy(roleQuery(role, nameOrOptions, options)),
+    locator: (selector) => new Locator(selectorExpression(selector), rt),
+    async tapAt(point) {
+      if (!isFinitePoint(point))
+        throw new E2eError2("INVALID_ARGUMENT", `tapAt needs finite x and y, got ${JSON.stringify(point)}`);
+      return rt.step(`tapAt (${point.x}, ${point.y})`, async () => {
+        const driver = await host.driver();
+        rt.drive("tapAt", await driver.tap(point));
+      });
+    },
+    swipe,
+    gesture: {
+      async pinch(options) {
+        assertScale(options.scale);
+        return rt.step(`pinch \xD7${options.scale}`, async () => {
+          const observed = await rt.observe();
+          const rect = screenRect(observed.snapshot.screen);
+          requireGesture(observed.driver, "pinch", "screen.gesture.pinch");
+          rt.drive("pinch", await observed.driver.pinch(options.center ?? centreOf(rect), options.scale, {
+            durationMs: options.durationMs ?? PINCH_MS,
+            radius: options.radius ?? pinchRadius(rect, options.scale, observed.snapshot.screen)
+          }));
+        });
+      },
+      async rotate(options) {
+        assertDegrees(options.degrees);
+        return rt.step(`rotate ${options.degrees}\xB0`, async () => {
+          const observed = await rt.observe();
+          const rect = screenRect(observed.snapshot.screen);
+          requireGesture(observed.driver, "pinch", "screen.gesture.rotate");
+          rt.drive("rotate", await observed.driver.rotate(options.center ?? centreOf(rect), options.degrees, {
+            durationMs: options.durationMs ?? ROTATE_MS,
+            radius: options.radius ?? rotateRadius(rect, observed.snapshot.screen)
+          }));
+        });
+      },
+      async path(options) {
+        const { paths } = options;
+        if (paths.length < 1 || paths.length > 2) {
+          throw new E2eError2("INVALID_ARGUMENT", `gesture.path takes 1 or 2 paths, got ${paths.length}`);
+        }
+        if (paths.some((points) => points.length < 1 || !points.every(isFinitePoint))) {
+          throw new E2eError2("INVALID_ARGUMENT", "gesture.path needs at least one point per path, all with finite x and y");
+        }
+        return rt.step(`gesture path (${paths.length} ${paths.length === 1 ? "finger" : "fingers"})`, async () => {
+          const driver = await host.driver();
+          requireGesture(driver, "path", "screen.gesture.path", paths.length);
+          rt.drive("gesture", await driver.gesture(paths.map((points) => ({ points: [...points] })), { durationMs: options.durationMs ?? PATH_MS }));
+        });
+      },
+      swipe
+    },
+    scrollUntilVisible: (target, options) => scrollUntilVisible(rt, target, options)
+  };
+}
+
+// ../../packages/e2e/src/traced-device.ts
+function traceDevice(device, span) {
+  if (span === undefined)
+    return device;
+  return {
+    get devtools() {
+      return device.devtools;
+    },
+    get perf() {
+      return device.perf;
+    },
+    alert: (action) => span("device.alert", () => device.alert(action), { detail: (answered) => ({ answered }) }),
+    openLink: (url, options) => span("device.openLink", () => device.openLink(url, options)),
+    home: () => span("device.home", () => device.home()),
+    back: () => span("device.back", () => device.back()),
+    orientation: (set) => span("device.orientation", () => device.orientation(set)),
+    appearance: (set) => span("device.appearance", () => device.appearance(set)),
+    clipboard: () => span("device.clipboard", () => device.clipboard()),
+    setClipboard: (text) => span("device.setClipboard", () => device.setClipboard(text)),
+    hideKeyboard: () => span("device.hideKeyboard", () => device.hideKeyboard()),
+    screenshot: (name) => span("device.screenshot", () => device.screenshot(name)),
+    snapshot: (options) => span("device.snapshot", () => device.snapshot(options)),
+    settle: (options) => span("device.settle", () => device.settle(options), {
+      detail: ({ quiet, waitedMs, via, reason, frontmostPid }) => ({
+        quiet,
+        waitedMs,
+        ...via === undefined ? {} : { via },
+        ...reason === undefined ? {} : { reason },
+        ...frontmostPid === undefined ? {} : { frontmostPid }
+      })
+    })
+  };
+}
+
+// ../../packages/e2e/src/fixtures.ts
+function screenHostFor(ctx, device) {
+  const { session } = ctx;
+  const alerts = ctx.systemAlerts;
+  const answerSystemAlert = device === undefined || alerts === undefined || alerts === "off" ? undefined : async () => !linkInFlight(session) && await device.alert(alerts);
+  const reactTree = session.env.metroUrl === undefined ? undefined : {
+    async tree(options) {
+      const attached = await session.devtools();
+      return attached.success ? attached.data.tree(options) : attached;
+    }
+  };
+  return {
+    devtools: () => reactTree,
+    driver: () => session.driver(),
+    env: { actionTimeoutMs: ctx.actionTimeoutMs, assertionTimeoutMs: ctx.assertionTimeoutMs },
+    get signal() {
+      return session.signal;
+    },
+    step: (label, fn) => session.step("locator", label, fn),
+    span: (op, fn, options) => session.span(op, fn, options),
+    ...answerSystemAlert === undefined ? {} : { answerSystemAlert }
+  };
+}
+async function defaultFixtureFactory(ctx) {
+  const { session } = ctx;
+  const driver = await session.driver();
+  const device = traceDevice(createDevice({ session, driver, env: session.env }), session.span);
+  return {
+    app: createApp({ session, driver, env: session.env }),
+    device,
+    screen: createScreen(screenHostFor(ctx, device)),
+    platform: session.env.platform
+  };
+}
+
+// ../../packages/e2e/src/preload.ts
+function versionMismatch(wardenVersion, e2eVersion) {
+  if (wardenVersion === undefined || wardenVersion === e2eVersion || e2eVersion === WORKSPACE_VERSION)
+    return;
+  return `warden e2e: @delacour/warden-e2e ${e2eVersion} does not match warden ${wardenVersion}, refusing to run; install the matching version: bun add -d @delacour/warden-e2e@${wardenVersion}`;
+}
+function isCi(env) {
+  const value = env.CI;
+  return value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
+}
+function installPreload(deps) {
+  const read = readEnv(deps.env);
+  if (!read.success) {
+    deps.stderr(`warden e2e: invalid environment
+${read.error}
+`);
+    deps.exit(2);
+    return;
+  }
+  if (read.data === undefined)
+    return;
+  const warning = versionMismatch(read.data.wardenVersion, deps.version);
+  if (warning !== undefined) {
+    deps.stderr(`${warning}
+`);
+    deps.exit(2);
+    return;
+  }
+  deps.setDefaultTimeout(read.data.timeoutMs + BUN_TIMEOUT_MARGIN_MS2);
+  const session = deps.createSession({ env: read.data });
+  deps.afterAll(async () => {
+    await session.close();
+    if (isCi(deps.env) && deps.onlySeen()) {
+      throw new E2eError2("INVALID_ARGUMENT", "test.only / test(..., { only: true }) is not allowed in CI");
+    }
+  });
+}
+if (!hasDefaultDriverFactory()) {
+  setDefaultDriverFactory(defaultDriverFactory);
+  setDefaultNativeLog(realNativeLogDeps(bunExec, androidTools(process.env).adb));
+  setDefaultHidRecovery({ exec: bunExec });
+}
+if (!hasDefaultFixtureFactory())
+  setDefaultFixtureFactory(defaultFixtureFactory);
+installPreload({
+  env: process.env,
+  setDefaultTimeout,
+  afterAll,
+  createSession: getSession,
+  version: WARDEN_E2E_VERSION2,
+  onlySeen: onlyWasSeen,
+  stderr: (text) => {
+    process.stderr.write(text);
+  },
+  exit: (code) => process.exit(code)
+});
+export {
+  BUN_TIMEOUT_MARGIN_MS2 as BUN_TIMEOUT_MARGIN_MS,
+  installPreload,
+  isCi,
+  versionMismatch
+};