@delacour/warden-e2e 0.1.1 → 0.2.0

package/preload.mjs

@@ -1,93 +1,78 @@
 // @bun
 import {
-  BUN_TIMEOUT_MARGIN_MS,
-  DEFAULT_ASSERTION_TIMEOUT_MS,
+  E2eError2,
+  noteSpanDetail,
+  addSpanDetail,
+  canObserve,
+  canDetectAlerts,
+  settleDetailOf,
   DEFAULT_SETTLE_QUIET_MS,
   DEFAULT_SETTLE_TIMEOUT_MS,
-  E2eError,
-  ENV_NAMES,
-  Locator,
-  PATH_MS,
+  settleByHash,
+  snapshotHash,
+  ok,
+  err,
+  swipeVector,
+  screenRect,
   PINCH_MS,
   ROTATE_MS,
-  WARDEN_E2E_VERSION,
-  WORKSPACE_VERSION,
-  addSpanDetail,
-  assertDegrees,
-  assertScale,
-  canDetectAlerts,
-  canObserve,
+  PATH_MS,
   centreOf,
-  err,
-  getSession,
-  hasDefaultDriverFactory,
-  hasDefaultFixtureFactory,
-  indexSnapshot,
-  isInteractiveRole,
-  isLocator,
-  locateByTestIdViaReact,
-  noteSpanDetail,
-  ok,
-  onlyWasSeen,
   pinchRadius,
-  readEnv,
-  renderHeader,
-  renderSnapshot,
+  rotateRadius,
   requireGesture,
+  assertScale,
+  assertDegrees,
+  isInteractiveRole,
   resolveRole,
+  indexSnapshot,
+  testIdQuery,
+  textQuery,
   roleQuery,
-  rotateRadius,
-  screenRect,
-  screenshotPath,
-  scrollUntilVisible,
   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,
-  settleByHash,
-  settleDetailOf,
-  snapshotHash,
-  swipeVector,
-  testIdQuery,
-  textQuery
-} from "./chunk-qtkmfjbq.mjs";
+  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/exec.ts
-import { existsSync } from "fs";
-function spawnFailure(cmd, cwd, error) {
-  if (cwd !== undefined && !existsSync(cwd))
-    return `cannot run \`${cmd.join(" ")}\`: no such directory ${cwd}`;
-  return `cannot run \`${cmd.join(" ")}\`: ${error instanceof Error ? error.message : String(error)}`;
-}
-var bunExec = async (cmd, opts = {}) => {
-  try {
-    const proc = Bun.spawn([...cmd], {
-      cwd: opts.cwd,
-      env: opts.env ? { ...process.env, ...opts.env } : process.env,
-      stdout: "pipe",
-      stderr: "pipe",
-      stdin: "ignore",
-      timeout: opts.timeoutMs,
-      ...opts.signal !== undefined ? { signal: opts.signal } : {}
-    });
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited
-    ]);
-    return { exitCode, stdout, stderr };
-  } catch (error) {
-    return { exitCode: 127, stdout: "", stderr: spawnFailure(cmd, opts.cwd, error) };
-  }
-};
-function execError(cmd, result) {
-  const detail = (result.stderr || result.stdout).trim().split(`
-`).slice(-3).join(" | ");
-  return `\`${cmd.join(" ")}\` exited ${result.exitCode}${detail ? `: ${detail}` : ""}`;
-}
-
 // ../../packages/core/src/providers/android.ts
 import { join as join2 } from "path";
 
@@ -119,26 +104,6 @@ var avdLists = new WeakMap;
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2 } from "path";
 
-// ../../packages/e2e/src/driver/errors.ts
-var RETRYABLE = new Set([
-  "E_TIMEOUT",
-  "E_HELPER_CRASHED",
-  "E_AX_UNAVAILABLE",
-  "E_APP_NOT_RESPONDING",
-  "E_STALE_REF"
-]);
-function driverError(code, message, extra = {}) {
-  return {
-    code,
-    message,
-    retryable: extra.retryable ?? RETRYABLE.has(code),
-    ...extra.detail !== undefined ? { detail: extra.detail } : {}
-  };
-}
-function driverErr(code, message, extra) {
-  return { success: false, error: driverError(code, message, extra) };
-}
-
 // ../../packages/e2e/src/driver/gesture-geometry.ts
 var GESTURE_FRAME_MS = 16;
 var GESTURE_MAX_FRAMES = 1000;
@@ -331,14 +296,14 @@ function openAdbSession(options) {
   function check(l) {
     if (!current)
       return;
-    const start2 = l.buffer.indexOf(current.prefix);
-    if (start2 < 0)
+    const start = l.buffer.indexOf(current.prefix);
+    if (start < 0)
       return;
-    const afterPrefix = start2 + current.prefix.length;
+    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, start2);
+    const stdout = l.buffer.slice(0, start);
     l.buffer = l.buffer.slice(afterPrefix + m[0].length);
     const settle = current.settle;
     current = undefined;
@@ -1231,8 +1196,8 @@ function createDumper(deps) {
   async function fetchRoute(route) {
     if (route === "tty") {
       try {
-        const res2 = await deps.exec(dumpTtyHostArgv(deps.adb, deps.serial), { timeoutMs: DUMP_TIMEOUT_MS });
-        return { text: res2.stdout };
+        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 } };
       }
@@ -1283,452 +1248,8 @@ function createDumper(deps) {
   };
 }
 
-// ../../packages/e2e/src/driver/ios/simd-protocol.ts
-import { z as z2 } from "zod";
-var protocolVersion = 1;
-var rectSchema = z2.object({
-  x: z2.number(),
-  y: z2.number(),
-  width: z2.number(),
-  height: z2.number()
-});
-var screenInfoSchema = z2.object({
-  width: z2.number(),
-  height: z2.number(),
-  scale: z2.number(),
-  rotation: z2.number().optional()
-});
-var ROLES = [
-  "button",
-  "text",
-  "textfield",
-  "securefield",
-  "searchfield",
-  "image",
-  "switch",
-  "checkbox",
-  "slider",
-  "link",
-  "cell",
-  "list",
-  "scrollview",
-  "tab",
-  "tabbar",
-  "alert",
-  "sheet",
-  "keyboard",
-  "navbar",
-  "toolbar",
-  "window",
-  "application",
-  "other"
-];
-var pointSchema = z2.object({ x: z2.number(), y: z2.number() });
-var wireElementSchema = z2.lazy(() => z2.object({
-  id: z2.string().nullish(),
-  role: z2.enum(ROLES),
-  rawType: z2.string(),
-  label: z2.string().nullish(),
-  identifier: z2.string().nullish(),
-  value: z2.string().nullish(),
-  text: z2.string().nullish(),
-  placeholder: z2.string().nullish(),
-  frame: rectSchema,
-  normFrame: rectSchema.nullish(),
-  traits: z2.array(z2.string()).nullish(),
-  enabled: z2.boolean().nullish(),
-  focused: z2.boolean().nullish(),
-  hidden: z2.boolean().nullish(),
-  selected: z2.boolean().nullish(),
-  checked: z2.boolean().nullish(),
-  hittable: z2.boolean().nullish(),
-  tapPoint: pointSchema.nullish(),
-  pid: z2.number().nullish(),
-  depth: z2.number().nullish(),
-  children: z2.array(wireElementSchema).nullish()
-}));
-var ROLE_SET = new Set(ROLES);
-var isBag = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isNum = (value) => typeof value === "number" && Number.isFinite(value);
-var isNullish = (value) => value === null || value === undefined;
-function isRect(value) {
-  return isBag(value) && isNum(value.x) && isNum(value.y) && isNum(value.width) && isNum(value.height);
-}
-var OPTIONAL_STRINGS = ["id", "label", "identifier", "value", "text", "placeholder"];
-var OPTIONAL_FLAGS = ["enabled", "focused", "hidden", "selected", "checked", "hittable"];
-var isString = (value) => typeof value === "string";
-var isBool = (value) => typeof value === "boolean";
-var isPoint = (value) => isBag(value) && isNum(value.x) && isNum(value.y);
-var isStringArray = (value) => Array.isArray(value) && value.every(isString);
-var orNullish = (value, check) => isNullish(value) || check(value);
-function hasValidOptionals(node) {
-  return OPTIONAL_STRINGS.every((key) => orNullish(node[key], isString)) && OPTIONAL_FLAGS.every((key) => orNullish(node[key], isBool)) && orNullish(node.normFrame, isRect) && orNullish(node.traits, isStringArray) && orNullish(node.tapPoint, isPoint) && orNullish(node.pid, isNum) && orNullish(node.depth, isNum);
-}
-function isWireElement(value) {
-  if (!isBag(value))
-    return false;
-  if (!isString(value.role) || !ROLE_SET.has(value.role))
-    return false;
-  if (!isString(value.rawType) || !isRect(value.frame) || !hasValidOptionals(value))
-    return false;
-  const { children } = value;
-  if (isNullish(children))
-    return true;
-  return Array.isArray(children) && children.every(isWireElement);
-}
-function wireElementProblem(value) {
-  const parsed = wireElementSchema.safeParse(value);
-  if (parsed.success)
-    return "invalid element";
-  const issue = parsed.error.issues[0];
-  return issue ? `${issue.path.join(".") || "(element)"}: ${issue.message}` : "invalid element";
-}
-var wireErrorSchema = z2.object({
-  code: z2.string(),
-  message: z2.string(),
-  retryable: z2.boolean().optional(),
-  detail: z2.unknown().optional()
-});
-var readyEventSchema = z2.object({
-  event: z2.literal("ready"),
-  protocol: z2.number(),
-  version: z2.string(),
-  udid: z2.string(),
-  hid: z2.object({ transport: z2.string() }),
-  ax: z2.object({ default: z2.string(), bridge: z2.string() }),
-  screen: screenInfoSchema
-});
-var logEventSchema = z2.object({
-  event: z2.literal("log"),
-  level: z2.enum(["debug", "info", "warn", "error"]),
-  message: z2.string(),
-  op: z2.string().optional(),
-  id: z2.string().optional()
-});
-var fatalEventSchema = z2.object({ event: z2.literal("fatal"), error: wireErrorSchema });
-var eventSchema = z2.discriminatedUnion("event", [readyEventSchema, logEventSchema, fatalEventSchema]);
-var responseSchema = z2.discriminatedUnion("ok", [
-  z2.object({ id: z2.string(), ok: z2.literal(true), data: z2.unknown().optional() }),
-  z2.object({ id: z2.string(), ok: z2.literal(false), error: wireErrorSchema })
-]);
-function parseLine(line) {
-  let json;
-  try {
-    json = JSON.parse(line);
-  } catch {
-    return { success: false, reason: "not JSON" };
-  }
-  if (typeof json === "object" && json !== null && "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}` };
-}
-var healthDataSchema = z2.looseObject({
-  version: z2.string(),
-  udid: z2.string(),
-  hid: z2.object({ transport: z2.string() }),
-  ax: z2.object({
-    default: z2.string(),
-    bridge: z2.enum(["available", "degraded", "missing", "failed"]),
-    error: z2.string().optional(),
-    lastError: z2.object({ message: z2.string(), agoMs: z2.number() }).optional()
-  }),
-  screen: screenInfoSchema,
-  socket: z2.object({ path: z2.string(), clients: z2.number() }).optional(),
-  idb: z2.string().optional(),
-  xcode: z2.string().optional(),
-  state: z2.string().optional(),
-  uptimeMs: z2.number().optional()
-});
-var snapshotDataSchema = z2.looseObject({
-  backend: z2.enum(["axbridge", "ax", "uiautomator"]),
-  screen: screenInfoSchema,
-  modal: z2.object({ pid: z2.number().optional(), description: z2.string().optional() }).nullish(),
-  truncated: z2.boolean(),
-  elements: z2.array(z2.custom(isWireElement, { error: (issue) => wireElementProblem(issue.input) })),
-  ms: z2.number(),
-  fallback: z2.object({ from: z2.string(), to: z2.string(), reason: z2.string() }).optional(),
-  readMs: z2.number().optional(),
-  nodes: z2.number().optional()
-});
-var elementAtPointDataSchema = wireElementSchema.nullable();
-var screenshotDataSchema = z2.looseObject({
-  path: z2.string().optional(),
-  png: z2.string().optional(),
-  width: z2.number().optional(),
-  height: z2.number().optional()
-});
-var settleDataSchema = z2.looseObject({
-  quiet: z2.boolean(),
-  waitedMs: z2.number(),
-  via: z2.enum(["stream", "snapshot"]).optional().catch(undefined),
-  reason: z2.string().optional(),
-  frontmostPid: z2.number().optional()
-});
-var rebindDataSchema = z2.looseObject({
-  bound: z2.boolean(),
-  waitedMs: z2.number(),
-  pid: z2.number().optional(),
-  restarts: z2.number().optional(),
-  recycled: z2.boolean().optional(),
-  reason: z2.string().optional()
-});
-var alertButtonsDataSchema = z2.object({
-  title: z2.string().optional(),
-  message: z2.string().optional(),
-  buttons: z2.array(wireElementSchema)
-}).nullable();
-var frontmostDataSchema = z2.looseObject({
-  frontmost: z2.boolean(),
-  pid: z2.number().optional(),
-  frontmostPid: z2.number().optional()
-});
-var orientationDataSchema = z2.object({
-  orientation: z2.enum([
-    "portrait",
-    "portraitUpsideDown",
-    "landscapeLeft",
-    "landscapeRight",
-    "faceUp",
-    "faceDown",
-    "unknown"
-  ]),
-  source: z2.enum(["device", "written", "assumed"]).optional()
-});
-var opSchemas = {
-  health: healthDataSchema,
-  snapshot: snapshotDataSchema,
-  elementAtPoint: elementAtPointDataSchema,
-  screenshot: screenshotDataSchema,
-  settle: settleDataSchema,
-  rebind: rebindDataSchema,
-  alertButtons: alertButtonsDataSchema,
-  frontmost: frontmostDataSchema,
-  orientation: orientationDataSchema
-};
-function hasOpSchema(op) {
-  return Object.hasOwn(opSchemas, op);
-}
-var DRIVER_CODES = new Set([
-  "E_HELPER_MISSING",
-  "E_HELPER_CRASHED",
-  "E_TIMEOUT",
-  "E_NOT_BOOTED",
-  "E_UNKNOWN_DEVICE",
-  "E_AX_UNAVAILABLE",
-  "E_APP_UNAVAILABLE",
-  "E_APP_NOT_RESPONDING",
-  "E_NO_ELEMENT",
-  "E_STALE_REF",
-  "E_UNSUPPORTED",
-  "E_UNSUPPORTED_TEXT",
-  "E_HID",
-  "E_IO",
-  "E_BAD_REQUEST",
-  "E_INTERNAL"
-]);
-function isDriverCode(code) {
-  return DRIVER_CODES.has(code);
-}
-function mapWireError(wire) {
-  const retryable = wire.retryable === undefined ? {} : { retryable: wire.retryable };
-  if (wire.code === "E_UNKNOWN_UDID") {
-    return driverError("E_UNKNOWN_DEVICE", wire.message, { ...retryable, detail: wire.detail });
-  }
-  if (isDriverCode(wire.code))
-    return driverError(wire.code, wire.message, { ...retryable, detail: wire.detail });
-  return driverError("E_INTERNAL", wire.message, {
-    ...retryable,
-    detail: { wireCode: wire.code, ...wire.detail !== undefined ? { wireDetail: wire.detail } : {} }
-  });
-}
-function createLineSplitter() {
-  const decoder = new TextDecoder("utf-8");
-  let buffer = "";
-  return {
-    push(chunk) {
-      buffer += decoder.decode(chunk, { stream: true });
-      const lines = buffer.split(`
-`);
-      buffer = lines.pop() ?? "";
-      return lines.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line).filter((line) => line.length > 0);
-    },
-    rest: () => buffer
-  };
-}
-function encodeRequest(request) {
-  return `${JSON.stringify(request)}
-`;
-}
-
-// ../../packages/e2e/src/driver/ios/simd-transport.ts
-var bunSpawn = (cmd) => {
-  const proc = Bun.spawn([...cmd], { stdin: "pipe", stdout: "pipe", stderr: "pipe" });
-  return {
-    write(data) {
-      proc.stdin.write(data);
-      proc.stdin.flush();
-    },
-    end() {
-      proc.stdin.end();
-    },
-    kill() {
-      proc.kill();
-    },
-    stdout: proc.stdout,
-    stderr: proc.stderr,
-    exited: proc.exited
-  };
-};
-async function pump(stream, onLine) {
-  const splitter = createLineSplitter();
-  const reader = stream.getReader();
-  try {
-    for (;; ) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      for (const line of splitter.push(value))
-        onLine(line);
-    }
-  } catch {}
-  const rest = splitter.rest().trim();
-  if (rest)
-    onLine(rest);
-}
-var STDERR_TAIL = 20;
-var DEFAULT_GRACE_MS = 1500;
-function stdioTransport(opts) {
-  const spawn = opts.spawn ?? bunSpawn;
-  const graceMs = opts.graceMs ?? DEFAULT_GRACE_MS;
-  return async (handlers) => {
-    let proc;
-    try {
-      proc = spawn(opts.cmd);
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      return {
-        success: false,
-        error: driverError("E_HELPER_MISSING", `cannot start ${opts.cmd[0]}: ${reason}`, {
-          detail: { cmd: opts.cmd }
-        })
-      };
-    }
-    const stderrTail = [];
-    const stdout = pump(proc.stdout, handlers.onLine);
-    const stderr = proc.stderr ? pump(proc.stderr, (line) => {
-      stderrTail.push(line);
-      if (stderrTail.length > STDERR_TAIL)
-        stderrTail.shift();
-      handlers.onDiagnostic(line);
-    }) : Promise.resolve();
-    const exited = proc.exited.catch(() => -1);
-    Promise.all([stdout, stderr, exited]).then(([, , exitCode]) => {
-      handlers.onClose({ exitCode, stderrTail: [...stderrTail] });
-    });
-    return {
-      success: true,
-      data: {
-        send: (data) => proc.write(data),
-        async close() {
-          try {
-            proc.end();
-          } catch {}
-          let timer;
-          const timedOut = new Promise((resolve) => {
-            timer = setTimeout(() => resolve("timeout"), graceMs);
-          });
-          const outcome = await Promise.race([exited.then(() => "exited"), timedOut]);
-          clearTimeout(timer);
-          if (outcome === "timeout") {
-            proc.kill();
-            await exited;
-          }
-        }
-      }
-    };
-  };
-}
-function socketTransport(opts) {
-  return async (handlers) => {
-    const splitter = createLineSplitter();
-    const encoder = new TextEncoder;
-    let socket;
-    let queued = new Uint8Array(0);
-    let closedNotified = false;
-    const notifyClosed = () => {
-      if (closedNotified)
-        return;
-      closedNotified = true;
-      handlers.onClose({ exitCode: null, stderrTail: [] });
-    };
-    const flush = () => {
-      if (!socket || queued.length === 0)
-        return;
-      const written = socket.write(queued);
-      queued = written >= queued.length ? new Uint8Array(0) : queued.slice(Math.max(written, 0));
-    };
-    try {
-      const connected = await Bun.connect({
-        unix: opts.socketPath,
-        socket: {
-          open(s) {
-            socket = s;
-          },
-          data(_s, chunk) {
-            for (const line of splitter.push(chunk))
-              handlers.onLine(line);
-          },
-          drain() {
-            flush();
-          },
-          close() {
-            notifyClosed();
-          },
-          error() {
-            notifyClosed();
-          },
-          end() {
-            notifyClosed();
-          }
-        }
-      });
-      socket = connected;
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      return {
-        success: false,
-        error: driverError("E_HELPER_CRASHED", `cannot connect to warden-simd socket ${opts.socketPath}: ${reason}`, {
-          detail: { socketPath: opts.socketPath }
-        })
-      };
-    }
-    return {
-      success: true,
-      data: {
-        send(data) {
-          const bytes = encoder.encode(data);
-          const merged = new Uint8Array(queued.length + bytes.length);
-          merged.set(queued, 0);
-          merged.set(bytes, queued.length);
-          queued = merged;
-          flush();
-        },
-        async close() {
-          try {
-            socket?.end();
-          } catch {}
-          notifyClosed();
-        }
-      }
-    };
-  };
-}
-
 // ../../packages/e2e/src/driver/android/uiad-protocol.ts
-import { z as z3 } from "zod";
+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"];
@@ -1786,48 +1307,48 @@ function readNode(value, path = "elements") {
   node.children = children;
   return node;
 }
-var screenSchema = z3.object({
-  width: z3.number(),
-  height: z3.number(),
-  scale: z3.number().optional(),
-  rotation: z3.number().optional()
+var screenSchema = z2.object({
+  width: z2.number(),
+  height: z2.number(),
+  scale: z2.number().optional(),
+  rotation: z2.number().optional()
 });
-var healthSchema = z3.looseObject({
-  version: z3.string(),
-  protocol: z3.number(),
-  sdk: z3.number(),
-  release: z3.string().optional(),
-  model: z3.string().optional(),
-  uid: z3.number().optional(),
-  pid: z3.number().optional(),
-  uiAutomation: z3.looseObject({ state: z3.string(), connect: z3.string().optional(), connectMs: z3.number().optional() }),
-  events: z3.looseObject({ count: z3.number(), lastAgoMs: z3.number() }).optional(),
-  uptimeMs: z3.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: z3.string().optional()
+  displayError: z2.string().optional()
 });
-var settleDataSchema2 = z3.looseObject({
-  quiet: z3.boolean(),
-  waitedMs: z3.number(),
-  via: z3.literal("events"),
-  events: z3.number(),
-  firstEventMs: z3.number().optional(),
-  reason: z3.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 = z3.looseObject({
-  text: z3.string(),
-  caret: z3.number().optional(),
-  caretPlaced: z3.boolean().optional()
+var textDataSchema = z2.looseObject({
+  text: z2.string(),
+  caret: z2.number().optional(),
+  caretPlaced: z2.boolean().optional()
 });
-var snapshotEnvelope = z3.looseObject({
-  backend: z3.literal("uiad"),
+var snapshotEnvelope = z2.looseObject({
+  backend: z2.literal("uiad"),
   screen: screenSchema,
-  windows: z3.array(z3.unknown()).optional(),
-  elements: z3.array(z3.unknown()),
-  truncated: z3.boolean(),
-  nodes: z3.number(),
-  readMs: z3.number(),
-  ms: z3.number()
+  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);
@@ -1844,13 +1365,13 @@ function readSnapshotData(data) {
   }
   return { ...envelope.data, elements };
 }
-var readyEventSchema2 = z3.object({
-  event: z3.literal("ready"),
-  protocol: z3.number(),
-  version: z3.string(),
+var readyEventSchema = z2.object({
+  event: z2.literal("ready"),
+  protocol: z2.number(),
+  version: z2.string(),
   data: healthSchema
 });
-var eventSchema2 = z3.discriminatedUnion("event", [readyEventSchema2, logEventSchema, fatalEventSchema]);
+var eventSchema = z2.discriminatedUnion("event", [readyEventSchema, logEventSchema, fatalEventSchema]);
 function parseUiadLine(line) {
   let json;
   try {
@@ -1859,7 +1380,7 @@ function parseUiadLine(line) {
     return { success: false, reason: "not JSON" };
   }
   if (isRecord(json) && "event" in json) {
-    const event = eventSchema2.safeParse(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);
@@ -1869,7 +1390,7 @@ function parseUiadLine(line) {
 // ../../packages/e2e/src/driver/android/uiad-client.ts
 var DEFAULT_READY_TIMEOUT_MS2 = 5000;
 var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
-var DEFAULT_GRACE_MS2 = 1000;
+var DEFAULT_GRACE_MS = 1000;
 var SHUTDOWN_WAIT_MS = 300;
 var NOT_SENT = { sent: false };
 function schemaReader(schema) {
@@ -1966,7 +1487,7 @@ async function startUiad(options) {
   const factory = stdioTransport({
     cmd: options.cmd,
     ...options.spawn ? { spawn: options.spawn } : { spawn: bunSpawn },
-    graceMs: options.graceMs ?? DEFAULT_GRACE_MS2
+    graceMs: options.graceMs ?? DEFAULT_GRACE_MS
   });
   const waiting = new Promise((resolve) => {
     settleHandshake = (result) => {
@@ -2044,7 +1565,7 @@ async function startUiad(options) {
         return through(await request("snapshot", { ...params }, opts), readSnapshot, "snapshot");
       },
       async settle(params) {
-        return through(await request("settle", params, { timeoutMs: params.timeoutMs + requestTimeoutMs }), schemaReader(settleDataSchema2), "settle");
+        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");
@@ -2126,12 +1647,12 @@ function uiadPresentCommand(devicePath, bytes) {
 var bunPushDex = async (argv, bytes) => {
   try {
     const proc = Bun.spawn([...argv], { stdin: bytes, stdout: "pipe", stderr: "pipe", timeout: 15000 });
-    const [out, err2, exitCode] = await Promise.all([
+    const [out, err, exitCode] = await Promise.all([
       new Response(proc.stdout).text(),
       new Response(proc.stderr).text(),
       proc.exited
     ]);
-    return { exitCode, output: `${out}${err2}`.trim() };
+    return { exitCode, output: `${out}${err}`.trim() };
   } catch (error) {
     return { exitCode: 127, output: error instanceof Error ? error.message : String(error) };
   }
@@ -3062,9 +2583,9 @@ function buildDriver(options, session, baseScreen, clock, execBinary, facts) {
   const orientation = async (set) => {
     if (set) {
       for (const argv of rotationArgvs(orientationToRotation(set))) {
-        const res2 = await input(shellCommand(argv));
-        if (!res2.success)
-          return res2;
+        const res = await input(shellCommand(argv));
+        if (!res.success)
+          return res;
       }
       return { success: true, data: set };
     }
@@ -3111,8 +2632,8 @@ function buildDriver(options, session, baseScreen, clock, execBinary, facts) {
   };
   const appearance = async (set) => {
     if (set) {
-      const res2 = await runChecked(session, shellCommand(uimodeSetArgv(set === "dark")), "E_UNSUPPORTED");
-      return res2.success ? { success: true, data: set } : res2;
+      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)
@@ -3121,12 +2642,12 @@ function buildDriver(options, session, baseScreen, clock, execBinary, facts) {
   };
   const clipboard = async () => driverErr("E_UNSUPPORTED", "Android has no public shell clipboard access; type ASCII with typeText");
   const health = async () => {
-    const [release, sdk2, model] = await Promise.all(["ro.build.version.release", "ro.build.version.sdk", "ro.product.model"].map((k) => session.run(shellCommand(getpropArgv(k)))));
+    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(sdk2)})`,
+      version: `Android ${text(release)} (sdk ${text(sdk)})`,
       transport: "adb",
       screen: baseScreen,
       detail: { model: text(model), dumpRoute: dumper.route() ?? null, uiad: uiad?.status() ?? "off" }
@@ -3159,7 +2680,7 @@ function buildDriver(options, session, baseScreen, clock, execBinary, facts) {
     orientation,
     settle,
     alert,
-    alertIn: (snapshot2) => detectAlert(snapshot2.flat),
+    alertIn: (snapshot) => detectAlert(snapshot.flat),
     appearance,
     clipboard,
     app: createAppCommands({
@@ -3180,7 +2701,7 @@ function buildDriver(options, session, baseScreen, clock, execBinary, facts) {
 }
 
 // ../../packages/e2e/src/driver/ios/ios-driver.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { dirname as dirname4, join as join6 } from "path";
 
 // ../../packages/e2e/src/driver/ios/ios-session.ts
@@ -3235,7 +2756,7 @@ function swappableClient(initial, o) {
 }
 
 // ../../packages/e2e/src/driver/ios/locate-helper.ts
-import { existsSync as existsSync2, realpathSync } from "fs";
+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";
@@ -3286,7 +2807,7 @@ function resolveHelper(o) {
     execPath: o.execPath ?? process.execPath,
     importDir: o.importDir ?? import.meta.dir,
     wardenHome: o.wardenHome ?? wardenHome(),
-    exists: o.exists ?? existsSync2,
+    exists: o.exists ?? existsSync,
     realpath: o.realpath ?? realpathSync,
     ...o.version ? { version: o.version } : {}
   });
@@ -3554,6 +3075,20 @@ 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, "\\$&");
 }
@@ -3645,7 +3180,26 @@ function createSimctl(deps) {
       const code = /is not installed/.test(reset.error) ? "E_APP_UNAVAILABLE" : "E_IO";
       return { success: false, error: driverError(code, reset.error) };
     },
-    pbcopy: (text) => runVoid(pbcopyArgv(udid, text)),
+    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 };
@@ -3682,299 +3236,6 @@ function createSimctl(deps) {
   };
 }
 
-// ../../packages/e2e/src/driver/ios/simd-client.ts
-var DEFAULT_TIMEOUT_MS = 1e4;
-var DEFAULT_READY_TIMEOUT_MS3 = 15000;
-var SHUTDOWN_TIMEOUT_MS2 = 500;
-var STDERR_TAIL2 = 20;
-function crashed(info, what) {
-  const exit = info?.exitCode === null || info?.exitCode === undefined ? "" : ` (exit ${info.exitCode})`;
-  const tail = info?.stderrTail.length ? `: ${info.stderrTail.slice(-3).join(" | ")}` : "";
-  return driverError("E_HELPER_CRASHED", `warden-simd ${what}${exit}${tail}`, {
-    detail: info ? { exitCode: info.exitCode, stderrTail: info.stderrTail } : undefined
-  });
-}
-async function createSimdClient(factory, options = {}) {
-  const defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS3;
-  const maxRespawns = options.maxRespawns ?? 0;
-  const shutdownOnClose = options.shutdownOnClose ?? false;
-  const log = options.log;
-  const pending = new Map;
-  const listeners = new Map;
-  let seq = 0;
-  let respawns = 0;
-  let closed = false;
-  let closing = false;
-  let shutdownAcked = false;
-  let current;
-  let opening;
-  let lastCrash;
-  let fatalError;
-  function emit(event, payload) {
-    for (const listener of listeners.get(event) ?? []) {
-      try {
-        listener(payload);
-      } catch (error) {
-        log?.(`[simd] ${event} listener threw: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  }
-  function failAll(error) {
-    for (const [id, entry] of pending) {
-      clearTimeout(entry.timer);
-      pending.delete(id);
-      entry.resolve({ success: false, error });
-    }
-  }
-  function handleResponse(response) {
-    respawns = 0;
-    const entry = pending.get(response.id);
-    if (!entry) {
-      log?.(`[simd] response for unknown id ${response.id} (timed out?)`);
-      return;
-    }
-    clearTimeout(entry.timer);
-    pending.delete(response.id);
-    entry.resolve(response.ok ? { success: true, data: response.data ?? null } : { success: false, error: mapWireError(response.error) });
-  }
-  function handleFatal(session, event) {
-    const error = mapWireError(event.error);
-    fatalError = error;
-    log?.(`[simd] fatal: ${error.code}: ${error.message}`);
-    emit("fatal", error);
-    if (session.handshaking) {
-      session.handshaking = false;
-      session.handshake({ success: false, error });
-    }
-    failAll(error);
-  }
-  function handleEvent(session, event) {
-    if (event.event === "log") {
-      log?.(`[simd] ${event.level}: ${event.message}`);
-      emit("log", event);
-    } else if (event.event === "fatal") {
-      handleFatal(session, event);
-    } else if (session.handshaking) {
-      session.handshaking = false;
-      session.ready = event;
-      emit("ready", event);
-      session.handshake({ success: true, data: event });
-    }
-  }
-  function handleMessage(session, message) {
-    if (message.kind === "response")
-      handleResponse(message.response);
-    else
-      handleEvent(session, message.event);
-  }
-  function handleLine(session, line) {
-    const parsed = parseLine(line);
-    if (!parsed.success) {
-      log?.(`[simd] ignoring line (${parsed.reason}): ${line.slice(0, 200)}`);
-      return;
-    }
-    handleMessage(session, parsed.message);
-  }
-  function handleClose(session, info) {
-    if (!session.alive)
-      return;
-    session.alive = false;
-    const expected = closed || closing;
-    emit("exit", { exitCode: info.exitCode, expected });
-    if (session.handshaking) {
-      session.handshaking = false;
-      session.handshake({ success: false, error: fatalError ?? crashed(info, "exited before it was ready") });
-      return;
-    }
-    if (fatalError)
-      return;
-    const error = crashed(info, expected ? "stopped" : "exited unexpectedly");
-    if (!expected)
-      lastCrash = error;
-    failAll(expected ? driverError("E_INTERNAL", "client closed", { retryable: false }) : error);
-  }
-  async function openSession() {
-    let resolveHandshake = () => {
-      return;
-    };
-    const handshake = new Promise((resolve2) => {
-      resolveHandshake = resolve2;
-    });
-    const session = { alive: true, handshake: resolveHandshake, handshaking: true };
-    const stderrTail = [];
-    const opened = await factory({
-      onLine: (line) => handleLine(session, line),
-      onDiagnostic: (line) => {
-        stderrTail.push(line);
-        if (stderrTail.length > STDERR_TAIL2)
-          stderrTail.shift();
-        log?.(`[simd:stderr] ${line}`);
-      },
-      onClose: (info) => handleClose(session, { ...info, stderrTail: info.stderrTail.length ? info.stderrTail : [...stderrTail] })
-    });
-    if (!opened.success)
-      return opened;
-    session.transport = opened.data;
-    let timer;
-    const timeout = new Promise((resolve2) => {
-      timer = setTimeout(() => resolve2({
-        success: false,
-        error: driverError("E_TIMEOUT", `warden-simd sent no ready event within ${readyTimeoutMs} ms`)
-      }), readyTimeoutMs);
-    });
-    const ready = await Promise.race([handshake, timeout]);
-    clearTimeout(timer);
-    if (!ready.success) {
-      session.handshaking = false;
-      session.alive = false;
-      await session.transport.close().catch(() => {
-        return;
-      });
-      return ready;
-    }
-    if (ready.data.protocol !== protocolVersion) {
-      session.alive = false;
-      await session.transport.close().catch(() => {
-        return;
-      });
-      return {
-        success: false,
-        error: driverError("E_INTERNAL", `warden-simd speaks protocol ${ready.data.protocol}, this client expects ${protocolVersion}; rebuild or reinstall the helper`, { retryable: false })
-      };
-    }
-    current = session;
-    return { success: true, data: session };
-  }
-  async function ensureSession() {
-    if (current?.alive)
-      return { success: true, data: current };
-    if (opening)
-      return opening;
-    if (respawns >= maxRespawns) {
-      return {
-        success: false,
-        error: lastCrash ?? driverError("E_HELPER_CRASHED", "warden-simd connection is closed")
-      };
-    }
-    respawns += 1;
-    log?.(`[simd] respawning helper (${respawns}/${maxRespawns})`);
-    opening = openSession().finally(() => {
-      opening = undefined;
-    });
-    return opening;
-  }
-  function validate(op, data) {
-    if (!hasOpSchema(op))
-      return { success: true, data };
-    const parsed = opSchemas[op].safeParse(data);
-    if (parsed.success)
-      return { success: true, data: parsed.data };
-    return {
-      success: false,
-      error: driverError("E_INTERNAL", `warden-simd returned an unexpected \`${op}\` payload: ${parsed.error.message}`, {
-        retryable: false
-      })
-    };
-  }
-  async function request(op, params, opts) {
-    if (closed)
-      return { success: false, error: driverError("E_INTERNAL", "warden-simd client is closed", { retryable: false }) };
-    if (fatalError)
-      return { success: false, error: fatalError };
-    const session = await ensureSession();
-    if (!session.success)
-      return session;
-    const transport = session.data.transport;
-    if (!transport)
-      return { success: false, error: driverError("E_INTERNAL", "warden-simd transport missing") };
-    const timeoutMs = opts.timeoutMs ?? defaultTimeoutMs;
-    const id = String(++seq);
-    const result = await new Promise((resolve2) => {
-      const timer = setTimeout(() => {
-        pending.delete(id);
-        resolve2({
-          success: false,
-          error: driverError("E_TIMEOUT", `warden-simd \`${op}\` timed out after ${timeoutMs} ms`, {
-            detail: { op, timeoutMs }
-          })
-        });
-      }, timeoutMs);
-      pending.set(id, { op, resolve: resolve2, timer });
-      try {
-        transport.send(encodeRequest({ timeoutMs, ...params, id, op }));
-      } catch (error) {
-        clearTimeout(timer);
-        pending.delete(id);
-        resolve2({
-          success: false,
-          error: crashed(undefined, `rejected the \`${op}\` request: ${error instanceof Error ? error.message : String(error)}`)
-        });
-      }
-    });
-    if (result.success && op === "shutdown")
-      shutdownAcked = true;
-    return result.success ? validate(op, result.data) : result;
-  }
-  const first = await openSession();
-  if (!first.success)
-    return first;
-  const client = {
-    get ready() {
-      const ready = current?.ready ?? first.data.ready;
-      if (!ready)
-        throw new Error("warden-simd client has no handshake");
-      return ready;
-    },
-    request: (op, params = {}, opts = {}) => request(op, params, opts),
-    on(event, handler) {
-      const stored = handler;
-      const set = listeners.get(event) ?? new Set;
-      set.add(stored);
-      listeners.set(event, set);
-      return () => {
-        set.delete(stored);
-      };
-    },
-    async close() {
-      if (closed)
-        return;
-      closing = true;
-      const session = current;
-      if (shutdownOnClose && session?.alive && !fatalError && !shutdownAcked) {
-        await request("shutdown", {}, { timeoutMs: SHUTDOWN_TIMEOUT_MS2 });
-      }
-      closed = true;
-      failAll(driverError("E_INTERNAL", "warden-simd client closed", { retryable: false }));
-      await session?.transport?.close().catch(() => {
-        return;
-      });
-    }
-  };
-  return { success: true, data: client };
-}
-function spawnSimd(options) {
-  const cmd = [
-    options.helperPath,
-    "--udid",
-    options.udid,
-    ...options.resources ? ["--resources", options.resources] : [],
-    ...options.args ?? []
-  ];
-  return createSimdClient(stdioTransport({ cmd, spawn: options.spawn, graceMs: options.graceMs }), {
-    ...options,
-    maxRespawns: options.maxRespawns ?? 1,
-    shutdownOnClose: options.shutdownOnClose ?? true
-  });
-}
-function connectSimd(options) {
-  return createSimdClient(socketTransport({ socketPath: options.socketPath }), {
-    ...options,
-    maxRespawns: options.maxRespawns ?? 0,
-    shutdownOnClose: options.shutdownOnClose ?? false
-  });
-}
-
 // ../../packages/e2e/src/driver/ios/type-budget.ts
 var TYPE_BASE_MS = 1e4;
 var TYPE_PER_CHAR_MS = 70;
@@ -4431,7 +3692,7 @@ async function connect(o, log) {
     helperPath: helper.data,
     udid: o.udid,
     log,
-    ...(o.exists ?? existsSync3)(resources) ? { resources } : {},
+    ...(o.exists ?? existsSync2)(resources) ? { resources } : {},
     ...o.spawn ? { spawn: o.spawn } : {},
     ...timeoutOption(o)
   });
@@ -4535,12 +3796,12 @@ function codeFor(code) {
   return "ACTION_FAILED";
 }
 function toE2eError(error, action) {
-  return new E2eError(codeFor(error.code), `${action} failed: ${error.code}: ${error.message}`);
+  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 E2eError("TIMEOUT", `${action} aborted (test deadline reached or cancelled)${detail}`);
+  return new E2eError2("TIMEOUT", `${action} aborted (test deadline reached or cancelled)${detail}`);
 }
 async function settled(call, action, signal) {
   if (signal === undefined)
@@ -4569,7 +3830,7 @@ async function unwrap(call, action, signal) {
 // ../../packages/e2e/src/fixture-session.ts
 var systemClock = {
   now: () => Date.now(),
-  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 };
 
 // ../../packages/e2e/src/app.ts
@@ -4606,11 +3867,11 @@ function parseWait(wait) {
   if (typeof wait === "object" && wait !== null && isLocator(wait.until)) {
     const { timeout } = wait;
     if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
-      throw new E2eError("INVALID_ARGUMENT", `app.open wait timeout must be a non-negative number, got ${timeout}`);
+      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 E2eError("INVALID_ARGUMENT", `app.open wait must be "quiet", "none" or { until: <locator made by screen> }, got ${describeWait(wait)}`);
+  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")
@@ -4689,7 +3950,7 @@ function createApp({ session, driver, env, log = stderrLog2, clock = systemClock
     async reinstall() {
       const path = env.appPath;
       if (path === undefined) {
-        throw new E2eError("INVALID_ARGUMENT", "app.reinstall() needs WARDEN_APP_PATH (the build to install) to be set");
+        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)
@@ -4762,11 +4023,11 @@ function createAlertReader({ driver, clock, signal }) {
 
 // ../../packages/e2e/src/device-devtools.ts
 function createDeviceDevtools(source) {
-  const connect2 = async () => {
+  const connect = async () => {
     const attached = await source.devtools();
     if (attached.success)
       return attached.data;
-    throw new E2eError("SESSION", `devtools unavailable: ${attached.error.message}`);
+    throw new E2eError2("SESSION", `devtools unavailable: ${attached.error.message}`);
   };
   const attach = () => source.devtools();
   return {
@@ -4786,24 +4047,24 @@ function createDeviceDevtools(source) {
     },
     network: {
       async entries(query) {
-        return (await connect2()).network.entries(query);
+        return (await connect()).network.entries(query);
       },
       async clear() {
-        await (await connect2()).network.clear();
+        await (await connect()).network.clear();
       }
     },
     console: {
       async lines() {
-        return (await connect2()).console.lines();
+        return (await connect()).console.lines();
       },
       async clear() {
-        (await connect2()).console.clear();
+        (await connect()).console.clear();
       },
       async mark(label) {
-        (await connect2()).console.mark(label);
+        (await connect()).console.mark(label);
       }
     },
-    connect: connect2
+    connect
   };
 }
 
@@ -4864,8 +4125,8 @@ async function lookForSheet(deps, plan, watch, started, remembered) {
   watch.lastSheetAt = now;
   watch.sheetSeenAt ??= now;
   const since = (at) => at === undefined ? Number.POSITIVE_INFINITY : now - at;
-  const settled2 = since(watch.sheetSeenAt) >= SHEET_SETTLE_MS && since(watch.lastPressAt) >= PRESS_GAP_MS;
-  if (!settled2)
+  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 };
@@ -4954,11 +4215,11 @@ function alertTarget(info, action, platform) {
   const target = findButton(buttons, action.button);
   if (target === undefined) {
     const names = buttons.map((b) => nameOf(b) ?? "?").join(", ");
-    throw new E2eError("ACTION_FAILED", `alert has no "${action.button}" button (buttons: ${names})`);
+    throw new E2eError2("ACTION_FAILED", `alert has no "${action.button}" button (buttons: ${names})`);
   }
   return target;
 }
-function createDevice({ session, driver, env, clock = systemClock }) {
+function createDevice({ session, driver, env, clock = systemClock, perfExec }) {
   const issued = new Map;
   const signal = () => session.signal;
   const pressAlertButton = async (button, action) => {
@@ -4980,7 +4241,7 @@ function createDevice({ session, driver, env, clock = systemClock }) {
       return false;
     }
   };
-  const readSnapshot2 = (opts) => unwrap(() => driver.snapshot(opts), "snapshot", signal());
+  const readSnapshot = (opts) => unwrap(() => driver.snapshot(opts), "snapshot", signal());
   const { devtools: attach, peekDevtools } = session;
   let devtools;
   const lazyDevtools = () => {
@@ -4995,10 +4256,19 @@ function createDevice({ session, driver, env, clock = systemClock }) {
     }
     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)
@@ -5014,7 +4284,7 @@ function createDevice({ session, driver, env, clock = systemClock }) {
     async openLink(url, options = {}) {
       const waitMs = options.waitMs ?? OPEN_LINK_WAIT_MS;
       if (!Number.isFinite(waitMs) || waitMs < 0) {
-        throw new E2eError("INVALID_ARGUMENT", `openLink waitMs must be a non-negative number, got ${String(waitMs)}`);
+        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;
@@ -5034,7 +4304,7 @@ function createDevice({ session, driver, env, clock = systemClock }) {
     },
     async back() {
       if (driver.platform === "ios") {
-        throw new E2eError("INVALID_ARGUMENT", "device.back() is Android only: iOS has no back key");
+        throw new E2eError2("INVALID_ARGUMENT", "device.back() is Android only: iOS has no back key");
       }
       await unwrap(() => driver.pressButton("back"), "press back", signal());
     },
@@ -5051,7 +4321,7 @@ function createDevice({ session, driver, env, clock = systemClock }) {
       await unwrap(() => driver.clipboard(text), "set clipboard", signal());
     },
     async hideKeyboard() {
-      const snapshot = await readSnapshot2();
+      const snapshot = await readSnapshot();
       if (!snapshot.flat.some((element) => element.role === "keyboard"))
         return;
       if (driver.platform === "ios")
@@ -5073,7 +4343,7 @@ function createDevice({ session, driver, env, clock = systemClock }) {
     },
     async snapshot(options = {}) {
       const interactiveOnly = options.interactiveOnly ?? false;
-      const snapshot = await readSnapshot2({ interactiveOnly });
+      const snapshot = await readSnapshot({ interactiveOnly });
       const rendered = renderSnapshot(snapshot, { interactiveOnly, refs: new Map });
       return [renderHeader({ snapshot, rendered, interactiveOnly }), ...rendered.lines].join(`
 `);
@@ -5086,7 +4356,7 @@ function createDevice({ session, driver, env, clock = systemClock }) {
         return settleDetailOf(native.data);
       if (native.error.code !== "E_UNSUPPORTED")
         throw toE2eError(native.error, "settle");
-      const polled = await settleByHash(async () => snapshotHash(await readSnapshot2()), {
+      const polled = await settleByHash(async () => snapshotHash(await readSnapshot()), {
         quietMs,
         timeoutMs,
         now: clock.now,
@@ -5102,16 +4372,16 @@ function createDevice({ session, driver, env, clock = systemClock }) {
 var systemClock2 = {
   now: () => Date.now(),
   sleep(ms, signal) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve) => {
       if (signal?.aborted)
-        return resolve2();
+        return resolve();
       const onAbort = () => {
         clearTimeout(timer);
-        resolve2();
+        resolve();
       };
       const timer = setTimeout(() => {
         signal?.removeEventListener("abort", onAbort);
-        resolve2();
+        resolve();
       }, ms);
       signal?.addEventListener("abort", onAbort, { once: true });
     });
@@ -5285,13 +4555,13 @@ class Runtime {
   }
 }
 function driverFailure(verb, error, code = "DRIVER") {
-  return new E2eError(code, `${verb} failed: ${error.code}: ${error.message}`);
+  return new E2eError2(code, `${verb} failed: ${error.code}: ${error.message}`);
 }
 function abortError(signal) {
   const reason = signal?.reason;
-  if (reason instanceof E2eError)
+  if (reason instanceof E2eError2)
     return reason;
-  return new E2eError("TIMEOUT", "the test was aborted before the action finished");
+  return new E2eError2("TIMEOUT", "the test was aborted before the action finished");
 }
 
 // ../../packages/e2e/src/screen/screen.ts
@@ -5306,7 +4576,7 @@ function createScreen(host) {
     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 E2eError("INVALID_ARGUMENT", "swipe takes either { direction, momentum? } or { from, to, durationMs? }, not a mix");
+      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) {
@@ -5316,7 +4586,7 @@ function createScreen(host) {
         return;
       }
       if (!isFinitePoint(options.from) || !isFinitePoint(options.to)) {
-        throw new E2eError("INVALID_ARGUMENT", "swipe needs finite coordinates for from and 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 };
@@ -5333,7 +4603,7 @@ function createScreen(host) {
     locator: (selector) => new Locator(selectorExpression(selector), rt),
     async tapAt(point) {
       if (!isFinitePoint(point))
-        throw new E2eError("INVALID_ARGUMENT", `tapAt needs finite x and y, got ${JSON.stringify(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));
@@ -5368,10 +4638,10 @@ function createScreen(host) {
       async path(options) {
         const { paths } = options;
         if (paths.length < 1 || paths.length > 2) {
-          throw new E2eError("INVALID_ARGUMENT", `gesture.path takes 1 or 2 paths, got ${paths.length}`);
+          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 E2eError("INVALID_ARGUMENT", "gesture.path needs at least one point per path, all with finite x and y");
+          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();
@@ -5393,6 +4663,9 @@ function traceDevice(device, span) {
     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()),
@@ -5479,17 +4752,20 @@ ${read.error}
     deps.exit(2);
     return;
   }
-  deps.setDefaultTimeout(read.data.timeoutMs + BUN_TIMEOUT_MARGIN_MS);
+  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 E2eError("INVALID_ARGUMENT", "test.only / test(..., { only: true }) is not allowed in CI");
+      throw new E2eError2("INVALID_ARGUMENT", "test.only / test(..., { only: true }) is not allowed in CI");
     }
   });
 }
-if (!hasDefaultDriverFactory())
+if (!hasDefaultDriverFactory()) {
   setDefaultDriverFactory(defaultDriverFactory);
+  setDefaultNativeLog(realNativeLogDeps(bunExec, androidTools(process.env).adb));
+  setDefaultHidRecovery({ exec: bunExec });
+}
 if (!hasDefaultFixtureFactory())
   setDefaultFixtureFactory(defaultFixtureFactory);
 installPreload({
@@ -5497,7 +4773,7 @@ installPreload({
   setDefaultTimeout,
   afterAll,
   createSession: getSession,
-  version: WARDEN_E2E_VERSION,
+  version: WARDEN_E2E_VERSION2,
   onlySeen: onlyWasSeen,
   stderr: (text) => {
     process.stderr.write(text);
@@ -5505,8 +4781,8 @@ installPreload({
   exit: (code) => process.exit(code)
 });
 export {
-  versionMismatch,
-  isCi,
+  BUN_TIMEOUT_MARGIN_MS2 as BUN_TIMEOUT_MARGIN_MS,
   installPreload,
-  BUN_TIMEOUT_MARGIN_MS
+  isCi,
+  versionMismatch
 };