@delacour/warden-e2e 0.6.0 → 0.8.0

package/{chunk-yb1hcjqm.mjs → chunk-vs5npy59.mjs}

@@ -21,6 +21,20 @@ function e2eErr(error) {
   return { success: false, error: E2eError2.from(error) };
 }
 
+// ../../packages/e2e/src/a11y/a11y-target.ts
+var registry = new WeakMap;
+function registerA11yTarget(target, hooks) {
+  registry.set(target, hooks);
+}
+function a11yTargetOf(target) {
+  return typeof target === "object" && target !== null ? registry.get(target) : undefined;
+}
+
+// ../../packages/e2e/src/driver/element-actions.ts
+function canActOnElements(driver) {
+  return typeof driver.pressElement === "function";
+}
+
 // ../../packages/e2e/src/driver/span-detail.ts
 import { AsyncLocalStorage } from "async_hooks";
 var collectors = new AsyncLocalStorage;
@@ -1272,6 +1286,24 @@ function head(entry) {
 function describeEntry(entry) {
   return head(entry).join(" ");
 }
+function a11yWords(entry) {
+  const a11y = entry.element.a11y;
+  if (!a11y)
+    return [];
+  const words = [];
+  if (a11y.hint)
+    words.push(`hint=${quote(a11y.hint, MAX_NAME)}`);
+  if (a11y.actions && a11y.actions.length > 0) {
+    words.push(`actions=[${a11y.actions.map((action) => quote(action, MAX_VALUE)).join(",")}]`);
+  }
+  if (a11y.a11yFocused)
+    words.push("a11y-focused");
+  if (a11y.important === false)
+    words.push("not-important");
+  if (a11y.liveRegion)
+    words.push(`live=${a11y.liveRegion}`);
+  return words;
+}
 function renderEntryLine(entry, options = {}) {
   const parts = [];
   if (options.ref !== undefined)
@@ -1282,6 +1314,8 @@ function renderEntryLine(entry, options = {}) {
   parts.push(...stateWords(entry));
   const { x, y, width, height } = entry.element.frame;
   parts.push(`(${Math.round(x)},${Math.round(y)} ${Math.round(width)}\xD7${Math.round(height)})`);
+  if (options.a11y)
+    parts.push(...a11yWords(entry));
   return `${"  ".repeat(options.indent ?? 0)}${parts.join(" ")}`;
 }
 function isListed(entry) {
@@ -1297,6 +1331,7 @@ function renderSnapshot(snapshot, options) {
   const visible = listed.slice(0, limit);
   const lines = visible.map((entry) => renderEntryLine(entry, {
     indent: options.interactiveOnly ? 0 : entry.depth,
+    ...options.a11y ? { a11y: true } : {},
     ...options.refs.has(entry.element.id) ? { ref: options.refs.get(entry.element.id) } : {}
   }));
   const omitted = listed.length - visible.length;
@@ -1842,7 +1877,12 @@ class Locator {
     const spec = { enabled: !withPosition, tapPointOnScreen: !withPosition };
     const found = (options.until === undefined ? await this.aimFromKept(spec, options.position) : undefined) ?? await this.actionable(spec, options.timeout ?? this.rt.actionTimeout(), true);
     const point = "react" in found ? reactTapPoint(found.react, options.position) : tapPointOf(found.entry, options.position);
-    this.rt.drive("tap", await found.observed.driver.tap(point));
+    const { driver } = found.observed;
+    if (!withPosition && "entry" in found && canActOnElements(driver)) {
+      if (this.rt.drive("tap", await driver.pressElement(found.entry.element)))
+        return found.observed.snapshot;
+    }
+    this.rt.drive("tap", await driver.tap(point));
     return found.observed.snapshot;
   }
   async arrivedWithin(plan, pressedOn) {
@@ -1953,6 +1993,10 @@ class Locator {
     }
     return this.act("swipe", async () => {
       const { entry, observed } = await this.actionable({ enabled: false, tapPointOnScreen: false }, options.timeout ?? this.rt.actionTimeout());
+      if (canActOnElements(observed.driver)) {
+        if (this.rt.drive("swipe", await observed.driver.scrollElement(options.direction, entry.element)))
+          return;
+      }
       const vector = swipeVector(options.direction, visibleRect(entry.element.frame, observed.snapshot.screen), options.momentum);
       this.rt.drive("swipe", await observed.driver.swipe(vector.from, vector.to, vector.options));
     });
@@ -2170,7 +2214,9 @@ async function scrollUntilVisible(rt, target, options = {}) {
         throw scrollGaveUp(target, entry === undefined, `${swipes} swipes ${direction}`, rt.excerpt(observed.snapshot));
       }
       const vector = swipeVector(direction, screenRect(observed.snapshot.screen), options.momentum);
-      rt.drive("scrollUntilVisible", await observed.driver.swipe(vector.from, vector.to, vector.options));
+      const scrolled = canActOnElements(observed.driver) && rt.drive("scrollUntilVisible", await observed.driver.scrollElement(direction));
+      if (!scrolled)
+        rt.drive("scrollUntilVisible", await observed.driver.swipe(vector.from, vector.to, vector.options));
       await observed.driver.settle(SCROLL_SETTLE);
     }
   });
@@ -3076,6 +3122,9 @@ function describeDevices(targets) {
   }
   return [...seen.values()].join(", ");
 }
+function sameDeviceName(served, wanted) {
+  return wanted !== undefined && served.replaceAll("+", " ") === wanted.replaceAll("+", " ");
+}
 function normalizeWsUrl(wsUrl, metroUrl) {
   const ws = new URL(wsUrl);
   const metro = new URL(metroUrl);
@@ -3094,7 +3143,11 @@ function selectTarget(targets, query, metroUrl) {
       (t) => t.reactNative?.logicalDeviceId === query.logicalDeviceId || urlDevice(t) === query.logicalDeviceId,
       "logicalDeviceId"
     ],
-    [query.deviceName, (t) => t.deviceName === query.deviceName, "deviceName"]
+    [
+      query.deviceName,
+      (t) => t.deviceName !== undefined && sameDeviceName(t.deviceName, query.deviceName),
+      "deviceName"
+    ]
   ];
   for (const [value, matches, label] of wanted) {
     if (!value)
@@ -4390,7 +4443,9 @@ var DRIVER_CODES = new Set([
   "E_HID",
   "E_IO",
   "E_BAD_REQUEST",
-  "E_INTERNAL"
+  "E_INTERNAL",
+  "E_DEVICE_LOCKED",
+  "E_REFUSED"
 ]);
 function isDriverCode(code) {
   return DRIVER_CODES.has(code);
@@ -4515,6 +4570,7 @@ function stdioTransport(opts) {
   };
 }
 function socketTransport(opts) {
+  const label = opts.tcp ? `${opts.tcp.hostname}:${opts.tcp.port}` : opts.socketPath ?? "";
   return async (handlers) => {
     const splitter = createLineSplitter();
     const encoder = new TextEncoder;
@@ -4534,37 +4590,35 @@ function socketTransport(opts) {
       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();
-          }
+      const socketHandlers = {
+        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();
         }
-      });
+      };
+      const connected = opts.tcp ? await Bun.connect({ hostname: opts.tcp.hostname, port: opts.tcp.port, socket: socketHandlers }) : await Bun.connect({ unix: opts.socketPath, socket: socketHandlers });
       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 }
+        error: driverError("E_HELPER_CRASHED", `cannot connect to warden-simd socket ${label}: ${reason}`, {
+          detail: { socketPath: label }
         })
       };
     }
@@ -4914,6 +4968,22 @@ function isHidLost(error) {
   const hidInvalidated = /\bE_HID\b/.test(error.message) && /dtuhidd connection[\s\S]*invalidated/.test(error.message);
   return hidInvalidated || /\bE_NOT_BOOTED\b/.test(error.message);
 }
+function isRunnerLost(error) {
+  if (!(error instanceof E2eError2) || error.code !== "ACTION_FAILED" && error.code !== "DRIVER")
+    return false;
+  return /\bE_HELPER_CRASHED\b/.test(error.message);
+}
+function isRecoverableLoss(error, deviceKind) {
+  return deviceKind === "physical" ? isRunnerLost(error) : isHidLost(error);
+}
+var RUNNER_RESTART_MS = 180000;
+async function restartRunnerHost(deps, argv, udid) {
+  if (argv === undefined || argv.length === 0)
+    return err("WARDEN_IOS_RUNNER_RESTART is not set");
+  const cmd = argv.map((arg) => arg.replaceAll("{udid}", udid));
+  const res = await deps.exec(cmd, { timeoutMs: RUNNER_RESTART_MS });
+  return res.exitCode === 0 ? ok(undefined) : err(execError(cmd, res));
+}
 async function rebootSim(deps, udid) {
   const down = ["xcrun", "simctl", "shutdown", udid];
   const shutdown = await deps.exec(down, { timeoutMs: SHUTDOWN_MS });
@@ -5042,8 +5112,328 @@ function traceDriver(driver, options) {
   return wrap(driver, "driver.");
 }
 
-// ../../packages/e2e/src/env.ts
+// ../../packages/core/src/a11y/a11y.config.ts
 import { z as z7 } from "zod";
+var A11Y_RULE_IDS = [
+  "missing-name",
+  "image-no-name",
+  "target-size",
+  "target-size-platform",
+  "duplicate-name",
+  "role-in-name",
+  "label-in-name",
+  "hidden-focusable",
+  "text-clipped",
+  "native"
+];
+var ruleId = z7.enum(A11Y_RULE_IDS);
+var a11yAuditConfigSchema = z7.object({
+  ignore: z7.array(z7.object({ rule: ruleId, identifier: z7.string().min(1).optional() }).strict()).optional(),
+  minSeverity: z7.enum(["error", "warning"]).optional(),
+  rules: z7.array(ruleId).min(1).optional()
+}).strict();
+function parseA11yAuditEnv(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return err("must be JSON");
+  }
+  const parsed = a11yAuditConfigSchema.safeParse(json);
+  if (parsed.success)
+    return ok(parsed.data);
+  return err(parsed.error.issues.map((i) => `${i.path.join(".") || "a11y"}: ${i.message}`).join("; "));
+}
+
+// ../../packages/core/src/conditions/conditions.config.ts
+import { z as z8 } from "zod";
+
+// ../../packages/core/src/duration.ts
+var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
+function parseDuration(input) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/.exec(input.trim());
+  if (!match?.[1])
+    return { success: false, error: `invalid duration "${input}" (use e.g. 30s, 10m, 2h)` };
+  return { success: true, data: Math.round(Number(match[1]) * (UNIT_MS[match[2] ?? "s"] ?? 1000)) };
+}
+
+// ../../packages/core/src/conditions/conditions.types.ts
+var PERMISSION_NAMES = [
+  "location",
+  "locationAlways",
+  "camera",
+  "photos",
+  "photosAdd",
+  "contacts",
+  "contactsLimited",
+  "notifications",
+  "microphone",
+  "calendar",
+  "reminders",
+  "motion",
+  "mediaLibrary",
+  "siri"
+];
+var TEXT_SIZE_NAMES = [
+  "extra-small",
+  "small",
+  "medium",
+  "large",
+  "extra-large",
+  "extra-extra-large",
+  "extra-extra-extra-large",
+  "accessibility-medium",
+  "accessibility-large",
+  "accessibility-extra-large",
+  "accessibility-extra-extra-large",
+  "accessibility-extra-extra-extra-large"
+];
+var CAMERA_FACINGS = ["back", "front"];
+var CONDITION_AREAS = [
+  "network",
+  "location",
+  "clock",
+  "permission",
+  "locale",
+  "a11y",
+  "battery",
+  "camera"
+];
+
+// ../../packages/core/src/conditions/network.presets.ts
+var NETWORK_PRESET_NAMES = ["edge", "3g", "4g", "lte", "wifi", "slow", "lossy"];
+var NETWORK_PRESETS = {
+  edge: {
+    emu: { speed: "200:240", delay: "175:225" },
+    shaping: { latencyMs: 400, jitterMs: 25, downKbps: 240, upKbps: 200, lossPct: 0 }
+  },
+  "3g": {
+    emu: { speed: "330:780", delay: "40:60" },
+    shaping: { latencyMs: 100, jitterMs: 10, downKbps: 780, upKbps: 330, lossPct: 0 }
+  },
+  "4g": {
+    emu: { speed: "9000:9000", delay: "70:100" },
+    shaping: { latencyMs: 170, jitterMs: 15, downKbps: 9000, upKbps: 9000, lossPct: 0 }
+  },
+  lte: {
+    emu: { speed: "10000:50000", delay: "20:30" },
+    shaping: { latencyMs: 50, jitterMs: 5, downKbps: 50000, upKbps: 1e4, lossPct: 0 }
+  },
+  wifi: {
+    emu: { speed: "33000:40000", delay: "0:1" },
+    shaping: { latencyMs: 2, jitterMs: 0, downKbps: 40000, upKbps: 33000, lossPct: 0 }
+  },
+  slow: {
+    emu: { speed: "400:400", delay: "900:1100" },
+    shaping: { latencyMs: 2000, jitterMs: 100, downKbps: 400, upKbps: 400, lossPct: 0 }
+  },
+  lossy: {
+    emu: { speed: "1000:1000", delay: "200:300" },
+    shaping: { latencyMs: 500, jitterMs: 50, downKbps: 1000, upKbps: 1000, lossPct: 10 }
+  }
+};
+var UNSHAPED = { latencyMs: 0, jitterMs: 0, downKbps: 0, upKbps: 0, lossPct: 0 };
+var UNSHAPED_EMU = { speed: "full", delay: "none" };
+var nonNegative = (value) => value === undefined || !Number.isFinite(value) ? 0 : Math.max(0, value);
+function customEmu(shaping) {
+  const { downKbps, upKbps, latencyMs, jitterMs } = shaping;
+  const speed = downKbps === 0 && upKbps === 0 ? UNSHAPED_EMU.speed : `${upKbps || downKbps}:${downKbps || upKbps}`;
+  const half = latencyMs / 2;
+  const min = Math.max(0, Math.round(half - jitterMs));
+  const max = Math.round(half + jitterMs);
+  const delay = max === 0 ? UNSHAPED_EMU.delay : `${min}:${max}`;
+  return { speed, delay };
+}
+function resolveNetwork(condition) {
+  switch (condition.kind) {
+    case "offline":
+      return { online: false };
+    case "online":
+      return { online: true, shaping: UNSHAPED, emu: UNSHAPED_EMU };
+    case "preset":
+      return { online: true, ...NETWORK_PRESETS[condition.preset] };
+    case "flap":
+      return resolveNetwork(condition.base ?? { kind: "online" });
+    case "custom": {
+      const shaping = {
+        latencyMs: nonNegative(condition.latencyMs),
+        jitterMs: nonNegative(condition.jitterMs),
+        downKbps: nonNegative(condition.downKbps),
+        upKbps: nonNegative(condition.upKbps),
+        lossPct: Math.min(100, nonNegative(condition.lossPct))
+      };
+      return { online: true, shaping, emu: customEmu(shaping) };
+    }
+  }
+}
+
+// ../../packages/core/src/conditions/text-size.ts
+var TEXT_SIZE_SCALE = {
+  "extra-small": 0.82,
+  small: 0.88,
+  medium: 0.94,
+  large: 1,
+  "extra-large": 1.12,
+  "extra-extra-large": 1.24,
+  "extra-extra-extra-large": 1.35,
+  "accessibility-medium": 1.6,
+  "accessibility-large": 1.9,
+  "accessibility-extra-large": 2.35,
+  "accessibility-extra-extra-large": 2.75,
+  "accessibility-extra-extra-extra-large": 3.1
+};
+var ANDROID_MAX_FONT_SCALE = 2;
+var ANDROID_MIN_FONT_SCALE = 0.5;
+var isName = (v) => TEXT_SIZE_NAMES.includes(v);
+function resolveTextSize(size) {
+  if (typeof size === "number") {
+    if (!Number.isFinite(size) || size <= 0)
+      return err(`text size must be a positive scale, got ${String(size)}`);
+    let best = TEXT_SIZE_NAMES[0];
+    for (const name of TEXT_SIZE_NAMES) {
+      if (Math.abs(TEXT_SIZE_SCALE[name] - size) < Math.abs(TEXT_SIZE_SCALE[best] - size))
+        best = name;
+    }
+    return ok({ category: best, scale: size });
+  }
+  if (!isName(size))
+    return err(`unknown text size "${String(size)}" (use ${TEXT_SIZE_NAMES.join(", ")} or a scale like 1.3)`);
+  return ok({ category: size, scale: TEXT_SIZE_SCALE[size] });
+}
+var androidFontScale = (scale) => Math.min(ANDROID_MAX_FONT_SCALE, Math.max(ANDROID_MIN_FONT_SCALE, Math.round(scale * 100) / 100));
+function appliedA11y(op, applied) {
+  return Object.fromEntries(Object.entries(op).filter(([key]) => applied.includes(key)));
+}
+
+// ../../packages/core/src/conditions/conditions.config.ts
+var NETWORK_WORDS = ["online", "offline", ...NETWORK_PRESET_NAMES];
+var nonNegative2 = z8.number().nonnegative().finite();
+var customNetworkSchema = z8.object({
+  latencyMs: nonNegative2.optional(),
+  jitterMs: nonNegative2.optional(),
+  downKbps: nonNegative2.optional(),
+  upKbps: nonNegative2.optional(),
+  lossPct: z8.number().min(0).max(100).optional()
+}).strict();
+var isoDate = z8.string().refine((v) => !Number.isNaN(Date.parse(v)), { message: "invalid date (use ISO 8601)" });
+var offsetDuration = z8.string().refine((v) => parseDuration(v).success, { message: "invalid duration (use e.g. 2d)" });
+var textSize = z8.union([z8.enum(TEXT_SIZE_NAMES), z8.number().positive().finite()]);
+var a11yConfigSchema = z8.object({
+  textSize: textSize.optional(),
+  boldText: z8.boolean().optional(),
+  contrast: z8.enum(["increased", "normal"]).optional(),
+  reduceMotion: z8.boolean().optional()
+}).strict();
+var conditionsConfigSchema = z8.object({
+  network: z8.union([z8.enum(NETWORK_WORDS), customNetworkSchema]).optional(),
+  location: z8.union([
+    z8.enum(["city-run", "city-bike", "freeway"]),
+    z8.object({
+      lat: z8.number().min(-90).max(90),
+      lon: z8.number().min(-180).max(180),
+      altM: z8.number().finite().optional()
+    }).strict()
+  ]).optional(),
+  clock: z8.union([
+    isoDate,
+    z8.object({ at: isoDate, frozen: z8.boolean().optional() }).strict(),
+    z8.object({ offset: offsetDuration }).strict()
+  ]).optional(),
+  permissions: z8.partialRecord(z8.enum(PERMISSION_NAMES), z8.enum(["granted", "denied", "unset"])).optional(),
+  locale: z8.string().min(1).optional(),
+  timezone: z8.string().min(1).optional(),
+  a11y: a11yConfigSchema.optional()
+}).strict();
+var cameraFeedInput = z8.union([
+  z8.string().min(1),
+  z8.object({ path: z8.string().min(1), loop: z8.boolean().optional() }).strict()
+]);
+var cameraConfigSchema = z8.object({ back: cameraFeedInput.optional(), front: cameraFeedInput.optional() }).strict().refine((v) => v.back !== undefined || v.front !== undefined, { message: "camera needs a back or a front asset" });
+var cameraFeedsSchema = z8.object({
+  back: z8.object({ path: z8.string().min(1), loop: z8.boolean() }).strict().optional(),
+  front: z8.object({ path: z8.string().min(1), loop: z8.boolean() }).strict().optional()
+}).strict();
+function parseCameraFeedsEnv(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return err("must be JSON");
+  }
+  const parsed = cameraFeedsSchema.safeParse(json);
+  return parsed.success ? ok(parsed.data) : err(parsed.error.issues.map((i) => i.message).join("; "));
+}
+var isWord = (v) => NETWORK_WORDS.includes(v);
+function toNetworkCondition(input) {
+  if (typeof input === "string") {
+    if (!isWord(input))
+      return err(`unknown network "${input}" (use ${NETWORK_WORDS.join(", ")})`);
+    if (input === "online" || input === "offline")
+      return ok({ kind: input });
+    return ok({ kind: "preset", preset: input });
+  }
+  if ("kind" in input)
+    return ok(input);
+  return ok({ kind: "custom", ...input });
+}
+function toLocation(input) {
+  if (typeof input === "string")
+    return { kind: "scenario", name: input };
+  return { kind: "point", lat: input.lat, lon: input.lon, ...input.altM === undefined ? {} : { altM: input.altM } };
+}
+function toClock(input) {
+  if (typeof input === "string")
+    return { kind: "fixed", at: new Date(input).toISOString() };
+  if ("offset" in input) {
+    const ms = parseDuration(input.offset);
+    return { kind: "offset", ms: ms.success ? ms.data : 0 };
+  }
+  const at = new Date(input.at).toISOString();
+  return input.frozen === true ? { kind: "frozen", at } : { kind: "fixed", at };
+}
+function normalizeConditions(config) {
+  const conditions = {};
+  if (config.network !== undefined) {
+    const network = toNetworkCondition(config.network);
+    if (!network.success)
+      return network;
+    conditions.network = network.data;
+  }
+  if (config.location !== undefined)
+    conditions.location = toLocation(config.location);
+  if (config.clock !== undefined)
+    conditions.clock = toClock(config.clock);
+  if (config.permissions !== undefined)
+    conditions.permissions = config.permissions;
+  if (config.locale !== undefined)
+    conditions.locale = config.locale;
+  if (config.timezone !== undefined)
+    conditions.timezone = config.timezone;
+  if (config.a11y !== undefined) {
+    const a11y = { ...config.a11y };
+    if (config.a11y.textSize !== undefined) {
+      const size = resolveTextSize(config.a11y.textSize);
+      if (!size.success)
+        return size;
+      a11y.fontScale = size.data.scale;
+    }
+    conditions.a11y = a11y;
+  }
+  return ok({ conditions });
+}
+function parseConditionsEnv(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return err("must be JSON");
+  }
+  const parsed = conditionsConfigSchema.safeParse(json);
+  return parsed.success ? ok(parsed.data) : err(parsed.error.issues.map((i) => i.message).join("; "));
+}
+
+// ../../packages/e2e/src/env.ts
+import { z as z9 } from "zod";
 var ENV_NAMES = {
   udid: "WARDEN_UDID",
   deviceName: "WARDEN_DEVICE_NAME",
@@ -5052,6 +5442,7 @@ var ENV_NAMES = {
   appPath: "WARDEN_APP_PATH",
   metroUrl: "WARDEN_METRO_URL",
   launchArgs: "WARDEN_LAUNCH_ARGS",
+  devClientScheme: "WARDEN_DEV_CLIENT_SCHEME",
   out: "WARDEN_E2E_OUT",
   timeout: "WARDEN_E2E_TIMEOUT",
   actionTimeout: "WARDEN_E2E_ACTION_TIMEOUT",
@@ -5060,57 +5451,98 @@ var ENV_NAMES = {
   helperDir: "WARDEN_HELPER_DIR",
   simd: "WARDEN_SIMD",
   simdSocket: "WARDEN_SIMD_SOCKET",
+  iosRunnerSocket: "WARDEN_IOS_RUNNER_SOCKET",
   logTimestamps: "WARDEN_LOG_TIMESTAMPS",
+  deviceKind: "WARDEN_DEVICE_KIND",
+  iosRunnerRestart: "WARDEN_IOS_RUNNER_RESTART",
   afterReboot: "WARDEN_AFTER_REBOOT",
   version: "WARDEN_VERSION",
   bin: "WARDEN_BIN",
   perf: "WARDEN_PERF",
-  perfBudgets: "WARDEN_PERF_BUDGETS"
+  perfBudgets: "WARDEN_PERF_BUDGETS",
+  conditions: "WARDEN_CONDITIONS",
+  leaseId: "WARDEN_LEASE_ID",
+  netproxyCommand: "WARDEN_NETPROXY_COMMAND",
+  biometrics: "WARDEN_BIOMETRICS",
+  a11yAudit: "WARDEN_A11Y_AUDIT",
+  a11y: "WARDEN_A11Y",
+  cameraFeeds: "WARDEN_CAMERA_FEEDS"
 };
 var DEFAULT_TIMEOUT_MS4 = 120000;
 var DEFAULT_ACTION_TIMEOUT_MS = 30000;
 var DEFAULT_ASSERTION_TIMEOUT_MS = 5000;
-var toggle = z7.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
-var millis = z7.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z7.number().int().positive());
-var launchArgs = z7.string().transform((raw, ctx) => {
+var toggle = z9.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
+var millis = z9.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z9.number().int().positive());
+var launchArgs = z9.string().transform((raw, ctx) => {
   try {
-    const parsed = z7.array(z7.string()).safeParse(JSON.parse(raw));
+    const parsed = z9.array(z9.string()).safeParse(JSON.parse(raw));
     if (parsed.success)
       return parsed.data;
   } catch {}
   ctx.addIssue({ code: "custom", message: "must be a JSON array of strings" });
-  return z7.NEVER;
+  return z9.NEVER;
+});
+var conditions = z9.string().transform((raw, ctx) => {
+  const parsed = parseConditionsEnv(raw);
+  if (parsed.success)
+    return parsed.data;
+  ctx.addIssue({ code: "custom", message: parsed.error });
+  return z9.NEVER;
+});
+var a11yAudit = z9.string().transform((raw, ctx) => {
+  const parsed = parseA11yAuditEnv(raw);
+  if (parsed.success)
+    return parsed.data;
+  ctx.addIssue({ code: "custom", message: parsed.error });
+  return z9.NEVER;
+});
+var cameraFeeds = z9.string().transform((raw, ctx) => {
+  const parsed = parseCameraFeedsEnv(raw);
+  if (parsed.success)
+    return parsed.data;
+  ctx.addIssue({ code: "custom", message: parsed.error });
+  return z9.NEVER;
 });
 var REQUIRED = "required when WARDEN_UDID is set";
-var schema = z7.object({
-  udid: z7.string().min(1),
-  deviceName: z7.string().optional(),
-  platform: z7.enum(["ios", "android"]).default("ios"),
-  bundleId: z7.string({ error: REQUIRED }).min(1, REQUIRED),
-  appPath: z7.string().optional(),
-  metroUrl: z7.string().optional(),
+var schema = z9.object({
+  udid: z9.string().min(1),
+  deviceName: z9.string().optional(),
+  platform: z9.enum(["ios", "android"]).default("ios"),
+  bundleId: z9.string({ error: REQUIRED }).min(1, REQUIRED),
+  appPath: z9.string().optional(),
+  metroUrl: z9.string().optional(),
+  devClientScheme: z9.string().min(1).optional(),
   launchArgs: launchArgs.default([]),
-  out: z7.string().optional(),
+  out: z9.string().optional(),
   timeout: millis.default(DEFAULT_TIMEOUT_MS4),
   actionTimeout: millis.default(DEFAULT_ACTION_TIMEOUT_MS),
   assertionTimeout: millis.default(DEFAULT_ASSERTION_TIMEOUT_MS),
-  specsDir: z7.string().optional(),
-  helperDir: z7.string().optional(),
-  simd: z7.string().optional(),
-  simdSocket: z7.string().optional(),
+  specsDir: z9.string().optional(),
+  helperDir: z9.string().optional(),
+  simd: z9.string().optional(),
+  simdSocket: z9.string().optional(),
+  iosRunnerSocket: z9.string().optional(),
   logTimestamps: toggle.default(false),
+  deviceKind: z9.enum(["physical"]).optional(),
+  iosRunnerRestart: launchArgs.optional(),
   afterReboot: launchArgs.optional(),
-  version: z7.string().optional(),
-  bin: z7.string().optional(),
-  perf: z7.string().optional(),
-  perfBudgets: z7.string().optional()
+  version: z9.string().optional(),
+  bin: z9.string().optional(),
+  perf: z9.string().optional(),
+  perfBudgets: z9.string().optional(),
+  conditions: conditions.optional(),
+  leaseId: z9.string().min(1).optional(),
+  netproxyCommand: launchArgs.pipe(z9.array(z9.string()).min(1)).optional(),
+  biometrics: toggle.optional(),
+  a11yAudit: a11yAudit.optional(),
+  cameraFeeds: cameraFeeds.optional()
 });
 function defined2(values) {
   return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
 }
 function parseArgv(raw) {
   try {
-    const parsed = z7.array(z7.string()).min(1).safeParse(JSON.parse(raw));
+    const parsed = z9.array(z9.string()).min(1).safeParse(JSON.parse(raw));
     if (parsed.success)
       return parsed.data;
   } catch {}
@@ -5131,13 +5563,23 @@ function toEnv(v, now) {
       deviceName: v.deviceName,
       appPath: v.appPath,
       metroUrl: v.metroUrl,
+      devClientScheme: v.devClientScheme,
       specsDir: v.specsDir,
       helperDir: v.helperDir,
       simd: v.simd,
       simdSocket: v.simdSocket,
+      iosRunnerSocket: v.iosRunnerSocket,
       wardenVersion: v.version,
       perfBudgets: v.perfBudgets
     }),
+    ...v.deviceKind === undefined ? {} : { deviceKind: v.deviceKind },
+    ...v.iosRunnerRestart === undefined ? {} : { iosRunnerRestart: v.iosRunnerRestart },
+    ...v.conditions === undefined ? {} : { conditions: v.conditions },
+    ...v.leaseId === undefined ? {} : { leaseId: v.leaseId },
+    ...v.netproxyCommand === undefined ? {} : { netproxyCommand: v.netproxyCommand },
+    ...v.biometrics === true ? { biometrics: true } : {},
+    ...v.a11yAudit === undefined ? {} : { a11yAudit: v.a11yAudit },
+    ...v.cameraFeeds === undefined ? {} : { cameraFeeds: v.cameraFeeds },
     ...v.afterReboot === undefined ? {} : { afterReboot: v.afterReboot },
     ...v.bin === undefined ? {} : { wardenBin: parseArgv(v.bin) },
     ...v.perf === undefined ? {} : {
@@ -5170,25 +5612,25 @@ function readEnv(env, opts = {}) {
 // ../../packages/e2e/src/runner/results.ts
 import { appendFileSync, mkdirSync } from "fs";
 import { dirname as dirname2 } from "path";
-import { z as z8 } from "zod";
-var testStatusSchema = z8.enum(["passed", "failed", "skipped", "timed-out"]);
-var testResultSchema = z8.object({
-  file: z8.string(),
-  title: z8.array(z8.string()),
+import { z as z10 } from "zod";
+var testStatusSchema = z10.enum(["passed", "failed", "skipped", "timed-out"]);
+var testResultSchema = z10.object({
+  file: z10.string(),
+  title: z10.array(z10.string()),
   status: testStatusSchema,
-  durationMs: z8.number(),
-  startedAt: z8.number(),
-  only: z8.boolean().optional(),
-  error: z8.object({
-    message: z8.string(),
-    code: z8.string().optional(),
-    stack: z8.string().optional()
+  durationMs: z10.number(),
+  startedAt: z10.number(),
+  only: z10.boolean().optional(),
+  error: z10.object({
+    message: z10.string(),
+    code: z10.string().optional(),
+    stack: z10.string().optional()
   }).optional(),
-  artifacts: z8.object({ dir: z8.string(), files: z8.array(z8.string()) }).optional(),
-  device: z8.object({
-    udid: z8.string(),
-    platform: z8.enum(["ios", "android"]),
-    name: z8.string().optional()
+  artifacts: z10.object({ dir: z10.string(), files: z10.array(z10.string()) }).optional(),
+  device: z10.object({
+    udid: z10.string(),
+    platform: z10.enum(["ios", "android"]),
+    name: z10.string().optional()
   })
 });
 function openResults(path) {
@@ -5260,6 +5702,8 @@ async function runStep(attempt, kind, label, fn, now = Date.now) {
 }
 
 // ../../packages/e2e/src/session.ts
+var ENROLL_TRIES = 5;
+var ENROLL_RETRY_MS = 500;
 function devtoolsTarget(env) {
   return { appId: env.bundleId, ...env.deviceName === undefined ? {} : { deviceName: env.deviceName } };
 }
@@ -5366,10 +5810,27 @@ function createSession(opts = {}) {
       await sleep(WARM_INTERVAL_MS);
     }
   }
+  async function recoverRunner(deps, name) {
+    if (hidRecovered) {
+      note(`iPhone ${name}: the runner connection was lost again after a restart; check the phone and retry`);
+      return false;
+    }
+    hidRecovered = true;
+    await resetDevice();
+    const restarted = await restartRunnerHost(deps, resolved.iosRunnerRestart, resolved.udid);
+    if (!restarted.success) {
+      note(`iPhone ${name}: runner connection lost, restart failed: ${restarted.error}`);
+      return false;
+    }
+    note(`iPhone ${name}: runner connection lost, runner host restarted; running the test again`);
+    return true;
+  }
   async function recoverHid() {
     if (hid === undefined || closing !== undefined)
       return false;
     const name = resolved.deviceName ?? resolved.udid;
+    if (resolved.deviceKind === "physical")
+      return recoverRunner(hid, name);
     if (hidRecovered) {
       note(`sim ${name}: HID connection lost again after a reboot; \`warden release <id> --shutdown\` and retry`);
       return false;
@@ -5391,6 +5852,24 @@ function createSession(opts = {}) {
     note(`sim ${name}: HID connection lost (Device Hub quit?), rebooted; running the test again`);
     return true;
   }
+  async function reenroll(driver) {
+    if (resolved.biometrics !== true || resolved.platform !== "ios" || resolved.deviceKind === "physical")
+      return driver;
+    const sleep = hid?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    for (let attempt = 1;attempt <= ENROLL_TRIES; attempt += 1) {
+      const state = await driver.biometrics("enroll");
+      if (!state.success) {
+        note(`biometrics enroll failed: ${state.error.code}: ${state.error.message}`);
+        return driver;
+      }
+      if (state.data.enrolled)
+        return driver;
+      if (attempt < ENROLL_TRIES)
+        await sleep(ENROLL_RETRY_MS);
+    }
+    note(`biometrics enroll did not take after ${ENROLL_TRIES} attempts`);
+    return driver;
+  }
   const session = {
     env: resolved,
     out,
@@ -5423,7 +5902,7 @@ function createSession(opts = {}) {
           throw new E2eError2("DRIVER", `${code}: ${message}`);
         }
         current = cacheObservations(traceDriver(result.data, { trace: () => attempt?.trace }));
-        return current;
+        return reenroll(current);
       }, (cause) => {
         opened = undefined;
         throw new E2eError2("DRIVER", cause instanceof Error ? cause.message : String(cause));
@@ -5579,133 +6058,2823 @@ function getSession(opts = {}) {
   return session;
 }
 
-// ../../packages/e2e/src/perf/device-perf.ts
-import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync } from "fs";
-import { join as join2 } from "path";
-
-// ../../packages/e2e/src/perf/budgets.ts
-var BUDGET_KEYS = ["startupColdMs", "jankPct", "maxCommitMs", "p95CpuPct", "peakMemoryMb"];
-function measured(report, metric) {
-  const m = report.metrics;
-  switch (metric) {
-    case "startupColdMs":
-      return m.startupColdMs;
-    case "jankPct":
-      return m.jankPct;
-    case "maxCommitMs":
-      return m.topCommitMs;
-    case "p95CpuPct":
-      return m.cpuP95Pct;
-    case "peakMemoryMb": {
-      const kb = Math.max(m.peakPssKb ?? 0, m.peakRssKb ?? 0);
-      return kb > 0 ? kb / 1024 : undefined;
-    }
-  }
+// ../../packages/e2e/src/a11y/speech.ts
+var ACTIONABLE_ROLES = new Set([
+  "button",
+  "switch",
+  "checkbox",
+  "slider",
+  "link",
+  "tab",
+  "textfield",
+  "securefield",
+  "searchfield"
+]);
+var INPUT_ROLES = new Set(["textfield", "securefield", "searchfield"]);
+var ON_VALUES = new Set(["1", "on", "true", "checked"]);
+var OFF_VALUES = new Set(["0", "off", "false", "unchecked"]);
+function clean(s) {
+  const t = s?.trim();
+  return t ? t : undefined;
+}
+function has(el, trait) {
+  return el.traits.includes(trait);
+}
+function isActionable(el, platform) {
+  if (ACTIONABLE_ROLES.has(el.role))
+    return true;
+  if (platform === "ios")
+    return has(el, "button") || has(el, "link") || has(el, "adjustable");
+  return has(el, "clickable") || has(el, "long-clickable") || has(el, "checkable");
+}
+function isFocusTarget(el, platform) {
+  return el.a11y?.focusable === true || isActionable(el, platform);
+}
+function isInput(el) {
+  return INPUT_ROLES.has(el.role);
+}
+function ownName(el, platform) {
+  const label = clean(el.label);
+  if (label)
+    return label;
+  const text = clean(el.text);
+  if (text)
+    return text;
+  if (isInput(el)) {
+    return platform === "android" ? clean(el.value) ?? clean(el.placeholder) : undefined;
+  }
+  if (el.role === "switch" || el.role === "checkbox")
+    return;
+  return platform === "android" ? clean(el.value) : undefined;
 }
-function checkBudgets(report, base, overrides) {
-  const budgets = { ...base, ...overrides };
-  const breaches = [];
-  for (const metric of BUDGET_KEYS) {
-    const budget = budgets[metric];
-    if (budget === undefined)
+function descendantTexts(el, platform, out) {
+  for (const child of el.children) {
+    if (child.hidden)
       continue;
-    const value = measured(report, metric);
-    if (value !== undefined && value > budget)
-      breaches.push({ metric, value, budget });
+    if (child.a11y?.important === false && child.children.length === 0)
+      continue;
+    const name = clean(child.label) ?? clean(child.text) ?? (child.role === "text" ? clean(child.value) : undefined);
+    if (name)
+      out.push(name);
+    else
+      descendantTexts(child, platform, out);
   }
-  return breaches;
 }
-var round = (n) => Math.round(n * 10) / 10;
-function describeBreaches(breaches, reportPath) {
-  const lines = breaches.map((b) => `  ${b.metric}: ${round(b.value)} > budget ${b.budget}`);
-  return [
-    `perf_budget: ${breaches.length} metric${breaches.length === 1 ? "" : "s"} over budget`,
-    ...lines,
-    ...reportPath === undefined ? [] : [`  report: ${reportPath}`]
-  ].join(`
-`);
+function hasActionableDescendant(el, platform) {
+  return el.children.some((c) => !c.hidden && (isActionable(c, platform) || hasActionableDescendant(c, platform)));
 }
-function parseBudgets(raw) {
-  if (raw === undefined || raw === "")
-    return {};
-  let json;
-  try {
-    json = JSON.parse(raw);
-  } catch {
-    return {};
+function accessibleName(el, platform) {
+  const own = ownName(el, platform);
+  if (own)
+    return own;
+  if (!isFocusTarget(el, platform) && el.role !== "text")
+    return;
+  if (el.children.length === 0 || hasActionableDescendant(el, platform))
+    return;
+  const parts = [];
+  descendantTexts(el, platform, parts);
+  return parts.length ? parts.join(platform === "ios" ? " " : ", ") : undefined;
+}
+function switchState(el) {
+  const v = clean(el.value)?.toLowerCase();
+  if (v && ON_VALUES.has(v))
+    return "on";
+  if (v && OFF_VALUES.has(v))
+    return "off";
+  if (el.checked !== undefined)
+    return el.checked ? "on" : "off";
+  if (has(el, "checked"))
+    return "on";
+  return;
+}
+function iosRoleWord(el) {
+  if (has(el, "header"))
+    return "heading";
+  if (has(el, "adjustable") || el.role === "slider")
+    return "adjustable";
+  if (has(el, "link") || el.role === "link")
+    return "link";
+  switch (el.role) {
+    case "switch":
+      return "switch button";
+    case "checkbox":
+      return "checkbox";
+    case "tab":
+      return "tab";
+    case "textfield":
+      return "text field";
+    case "securefield":
+      return "secure text field";
+    case "searchfield":
+      return "search field";
+    case "image":
+      return "image";
+    case "button":
+      return "button";
+    default:
   }
-  if (typeof json !== "object" || json === null)
-    return {};
-  const out = {};
-  for (const key of BUDGET_KEYS) {
-    const v = json[key];
-    if (typeof v === "number" && Number.isFinite(v) && v >= 0)
-      out[key] = v;
+  if (has(el, "button"))
+    return "button";
+  if (has(el, "image"))
+    return "image";
+  return;
+}
+function androidRoleWord(el) {
+  if (has(el, "heading") || has(el, "header"))
+    return "heading";
+  if (has(el, "link") || el.role === "link")
+    return "link";
+  switch (el.role) {
+    case "switch":
+      return "switch";
+    case "checkbox":
+      return "checkbox";
+    case "textfield":
+    case "securefield":
+    case "searchfield":
+      return "edit box";
+    case "image":
+      return "image";
+    case "button":
+      return "button";
+    case "tab":
+      return "tab";
+    case "slider":
+      return "seek control";
+    default:
   }
-  return out;
+  if (has(el, "checkable"))
+    return "checkbox";
+  return;
+}
+function expandedState(el) {
+  if (has(el, "expanded"))
+    return "expanded";
+  if (has(el, "collapsed"))
+    return "collapsed";
+  return;
+}
+function join2(parts) {
+  return parts.filter((p) => !!p).join(", ");
+}
+function announceIos(el, opts) {
+  const label = accessibleName(el, "ios");
+  const toggle = el.role === "switch" || el.role === "checkbox" ? switchState(el) : undefined;
+  const rawValue = clean(el.value);
+  let value;
+  if (el.role === "securefield")
+    value = undefined;
+  else if (isInput(el))
+    value = rawValue ?? clean(el.placeholder);
+  else if (!toggle && el.role !== "text" && rawValue && rawValue !== label)
+    value = rawValue;
+  const role = iosRoleWord(el);
+  const state = [];
+  if (toggle)
+    state.push(toggle);
+  if (el.selected || has(el, "selected"))
+    state.push("selected");
+  const expanded = expandedState(el);
+  if (expanded)
+    state.push(expanded);
+  if (!el.enabled || has(el, "not-enabled"))
+    state.push("dimmed");
+  const hint = opts.hints === false ? undefined : clean(el.a11y?.hint);
+  return build(el, "ios", { label, value, role, state, hint }, join2([label, value, role, ...state, hint]));
+}
+function announceAndroid(el, opts) {
+  const name = accessibleName(el, "android");
+  const state = [];
+  const toggle = switchState(el);
+  if (el.role === "switch") {
+    if (toggle)
+      state.push(toggle);
+  } else if (el.role === "checkbox" || has(el, "checkable")) {
+    const checked = el.checked ?? has(el, "checked");
+    state.push(checked ? "checked" : "not checked");
+  }
+  if (el.selected || has(el, "selected"))
+    state.push("selected");
+  const expanded = expandedState(el);
+  if (expanded)
+    state.push(expanded);
+  const role = androidRoleWord(el);
+  const disabled = !el.enabled;
+  const hint = opts.hints === false ? undefined : clean(el.a11y?.hint);
+  const text = join2([...state, name, role, disabled ? "disabled" : undefined, hint]);
+  return build(el, "android", { label: name, role, state: disabled ? [...state, "disabled"] : state, hint }, text);
+}
+function build(el, platform, parts, text) {
+  const { label, value, role, state, hint } = parts;
+  return {
+    id: el.id,
+    ...el.identifier ? { identifier: el.identifier } : {},
+    text,
+    role: el.role,
+    platform,
+    source: "simulated",
+    parts: {
+      ...label ? { label } : {},
+      ...value ? { value } : {},
+      ...role ? { role } : {},
+      state,
+      ...hint ? { hint } : {}
+    }
+  };
+}
+function announce(el, platform, opts = {}) {
+  return platform === "ios" ? announceIos(el, opts) : announceAndroid(el, opts);
 }
 
-// ../../packages/e2e/src/perf/device-perf.ts
-var PERF_DIR = "perf";
-function parseEnvelope2(stdout) {
-  try {
-    const json = JSON.parse(stdout.trim().split(`
-`).at(-1) ?? "");
-    if (typeof json !== "object" || json === null || !("ok" in json))
-      return;
-    return json;
-  } catch {
+// ../../packages/e2e/src/a11y/order.ts
+function onScreen(el, screen) {
+  const f = el.frame;
+  if (f.width <= 0 || f.height <= 0)
+    return false;
+  return f.x < screen.width && f.y < screen.height && f.x + f.width > 0 && f.y + f.height > 0;
+}
+function verticalOverlap(a, b) {
+  const top = Math.max(a.frame.y, b.frame.y);
+  const bottom = Math.min(a.frame.y + a.frame.height, b.frame.y + b.frame.height);
+  return bottom - top;
+}
+function rowMajor(items) {
+  const byTop = [...items].sort((a, b) => a.frame.y - b.frame.y || a.frame.x - b.frame.x);
+  const rows = [];
+  for (const el of byTop) {
+    const row = rows.find((r) => {
+      const anchor = r[0];
+      return anchor !== undefined && verticalOverlap(anchor, el) > 0.5 * Math.min(anchor.frame.height, el.frame.height);
+    });
+    if (row)
+      row.push(el);
+    else
+      rows.push([el]);
+  }
+  return rows.flatMap((r) => r.sort((a, b) => a.frame.x - b.frame.x));
+}
+function orderSiblings(children, platform) {
+  if (platform === "android")
+    return children;
+  const explicit = children.filter((c) => c.a11y?.order !== undefined);
+  if (explicit.length > 0) {
+    const rest = children.filter((c) => c.a11y?.order === undefined);
+    return [...explicit.sort((a, b) => (a.a11y?.order ?? 0) - (b.a11y?.order ?? 0)), ...rowMajor(rest)];
+  }
+  return rowMajor(children);
+}
+function hasActionableDescendant2(el, platform) {
+  return el.children.some((c) => !c.hidden && (isActionable(c, platform) || hasActionableDescendant2(c, platform)));
+}
+function hasSpokenDescendant(el, platform) {
+  return el.children.some((c) => !c.hidden && (isActionable(c, platform) || accessibleName(c, platform) !== undefined || hasSpokenDescendant(c, platform)));
+}
+var CONTAINERS = new Set([
+  "application",
+  "window",
+  "toolbar",
+  "navbar",
+  "tabbar",
+  "list",
+  "scrollview"
+]);
+function swallows(el, platform, actionable) {
+  if (actionable)
+    return !hasActionableDescendant2(el, platform);
+  return el.a11y?.focusable === true || !hasSpokenDescendant(el, platform);
+}
+function walk(el, platform, screen, opts, out) {
+  if (el.hidden)
     return;
+  const visible = el.a11y?.important !== false && onScreen(el, screen);
+  if (visible) {
+    const actionable = isActionable(el, platform);
+    const container = CONTAINERS.has(el.role) && !actionable;
+    const named = accessibleName(el, platform) !== undefined;
+    if (!container && (actionable || named)) {
+      if (swallows(el, platform, actionable)) {
+        out.push({ el, announcement: announce(el, platform, opts) });
+        return;
+      }
+      if (named)
+        out.push({ el, announcement: announce(el, platform, opts) });
+    }
   }
+  for (const child of orderSiblings(el.children, platform))
+    walk(child, platform, screen, opts, out);
 }
-var flagsOf = (o) => [
-  ...o.js ? ["--js"] : [],
-  ...o.react ? ["--react"] : [],
-  ...typeof o.native === "string" ? [`--native=${o.native}`] : o.native ? ["--native"] : [],
-  ...o.metrics ? ["--metrics"] : [],
-  ...o.frames ? ["--frames"] : [],
-  ...o.logs ? ["--logs"] : [],
-  ...o.all ? ["--all"] : [],
-  ...o.relaunch ? ["--relaunch"] : [],
-  ...o.reset ? ["--reset"] : [],
-  ...o.maxDurationMs === undefined ? [] : ["--max-duration", `${Math.ceil(o.maxDurationMs / 1000)}s`]
-];
-var isRecord = (v) => typeof v === "object" && v !== null;
-function saveReport(deps, result, report, sessionId) {
-  const sessionReport = typeof result.reportPath === "string" ? result.reportPath : undefined;
-  const attempt = deps.attemptDir();
-  if (attempt === undefined)
-    return sessionReport;
-  const out = join2(attempt, PERF_DIR);
-  mkdirSync3(out, { recursive: true });
-  const sessionDir = typeof result.dir === "string" ? result.dir : undefined;
-  const write = (name, from, fallback) => {
-    if (from !== undefined && existsSync3(from))
-      copyFileSync(from, join2(out, name));
-    else if (fallback !== undefined)
-      writeFileSync(join2(out, name), fallback);
-    else
-      return;
-    deps.addFile?.(`${PERF_DIR}/${name}`);
-  };
-  write("report.json", sessionReport, `${JSON.stringify(report, null, 2)}
-`);
-  write("report.md", sessionDir === undefined ? undefined : join2(sessionDir, "report.md"));
-  write("session.json", undefined, `${JSON.stringify({ sessionId, dir: sessionDir }, null, 2)}
-`);
-  return join2(out, "report.json");
+function readingOrder(snapshot, platform, opts = {}) {
+  const out = [];
+  for (const el of orderSiblings(snapshot.elements, platform))
+    walk(el, platform, snapshot.screen, opts, out);
+  return out.map((e) => e.announcement);
 }
-function createDevicePerf(deps) {
-  const run = async (sub, extra) => {
-    if (deps.unavailable !== undefined)
-      throw new E2eError2("SESSION", `device.perf unavailable: ${deps.unavailable}`);
-    const { code, stdout, stderr } = await deps.exec(["perf", sub, "--json", "--udid", deps.udid, ...extra]);
+
+// ../../packages/e2e/src/a11y/rules/rule.context.ts
+function unitsPerPoint(snapshot) {
+  return snapshot.platform === "android" ? snapshot.screen.scale || 1 : 1;
+}
+function isAncestor(a, b, parents) {
+  for (let p = parents.get(b);p; p = parents.get(p))
+    if (p === a)
+      return true;
+  return false;
+}
+function related(a, b, parents) {
+  return a === b || isAncestor(a, b, parents) || isAncestor(b, a, parents);
+}
+function issue(rule, severity, el, message, wcag) {
+  return {
+    rule,
+    severity,
+    source: "warden",
+    elementId: el.id,
+    message,
+    ...wcag === undefined ? {} : { wcag },
+    ...el.identifier === undefined ? {} : { identifier: el.identifier }
+  };
+}
+function describe(el) {
+  const what = el.identifier ?? el.label ?? el.text ?? el.rawType;
+  return `${el.role} "${what}"`;
+}
+
+// ../../packages/e2e/src/a11y/rules/duplicate-name.ts
+var key = (s) => s.trim().toLowerCase().replace(/\s+/g, " ");
+var sameFrame2 = (a, b) => a.frame.x === b.frame.x && a.frame.y === b.frame.y && a.frame.width === b.frame.width && a.frame.height === b.frame.height;
+var duplicateName = (_snapshot, ctx) => {
+  const named = ctx.reachable.flatMap((el) => {
+    if (!isActionable(el, ctx.platform))
+      return [];
+    const name = accessibleName(el, ctx.platform);
+    return name === undefined ? [] : [{ el, name: key(name), raw: name }];
+  });
+  const out = [];
+  const kept = [];
+  for (const n of named) {
+    const first = kept.find((k) => k.name === n.name && !sameFrame2(k.el, n.el) && !related(k.el, n.el, ctx.parents) && !(k.el.identifier !== undefined && k.el.identifier === n.el.identifier));
+    if (first) {
+      out.push(issue("duplicate-name", "warning", n.el, `${describe(n.el)} is announced "${n.raw}", the same as ${describe(first.el)}`, "2.4.6"));
+    } else
+      kept.push(n);
+  }
+  return out;
+};
+
+// ../../packages/e2e/src/a11y/rules/hidden-focusable.ts
+function offScreen(el, screen) {
+  const f = el.frame;
+  return f.x >= screen.width || f.y >= screen.height || f.x + f.width <= 0 || f.y + f.height <= 0;
+}
+var hiddenFocusable = (snapshot) => snapshot.flat.filter((el) => el.a11y?.focusable === true && el.a11y.important !== false).flatMap((el) => {
+  const why = el.hidden ? "hidden" : el.frame.width <= 0 || el.frame.height <= 0 ? "zero-size" : offScreen(el, snapshot.screen) ? "off screen" : undefined;
+  return why ? [issue("hidden-focusable", "warning", el, `${describe(el)} is ${why} but still focusable`)] : [];
+});
+
+// ../../packages/e2e/src/a11y/rules/image-no-name.ts
+var imageNoName = (_snapshot, ctx) => ctx.reachable.filter((el) => el.role === "image" && accessibleName(el, ctx.platform) === undefined).map((el) => issue("image-no-name", "error", el, `${describe(el)} has no name (add a label, or mark it decorative)`, "1.1.1"));
+
+// ../../packages/e2e/src/a11y/rules/label-in-name.ts
+var norm = (s) => s.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "");
+function visibleText(el, platform) {
+  const own = platform === "android" ? el.text?.trim() : undefined;
+  if (own)
+    return own;
+  const parts = [];
+  const walk = (e) => {
+    for (const c of e.children) {
+      if (c.hidden)
+        continue;
+      if (c.role === "text") {
+        const t = (c.text ?? c.label ?? c.value)?.trim();
+        if (t)
+          parts.push(t);
+      } else
+        walk(c);
+    }
+  };
+  walk(el);
+  return parts.join(" ");
+}
+var labelInName = (_snapshot, ctx) => ctx.reachable.flatMap((el) => {
+  if (!isActionable(el, ctx.platform) || !el.label?.trim())
+    return [];
+  const visible = visibleText(el, ctx.platform);
+  const name = accessibleName(el, ctx.platform);
+  if (!visible || !name || norm(name).includes(norm(visible)))
+    return [];
+  return [issue("label-in-name", "error", el, `${describe(el)} shows "${visible}" but is named "${name}"`, "2.5.3")];
+});
+
+// ../../packages/e2e/src/a11y/rules/missing-name.ts
+function isScrollContainer(el, platform) {
+  const scrolls = el.role === "scrollview" || el.role === "list" || el.traits.includes("scrollable");
+  return scrolls && !isActionable(el, platform);
+}
+var missingName = (_snapshot, ctx) => ctx.reachable.filter((el) => isFocusTarget(el, ctx.platform) && !isScrollContainer(el, ctx.platform) && accessibleName(el, ctx.platform) === undefined).map((el) => issue("missing-name", "error", el, `${describe(el)} has no accessible name`, "4.1.2"));
+
+// ../../packages/e2e/src/a11y/rules/role-in-name.ts
+var WORDS = {
+  button: /\b(button|btn)\b/i,
+  image: /\b(image|icon)\b/i
+};
+var roleInName = (_snapshot, ctx) => ctx.reachable.flatMap((el) => {
+  const pattern = WORDS[el.role];
+  const name = pattern ? accessibleName(el, ctx.platform) : undefined;
+  const hit = name ? pattern?.exec(name)?.[0] : undefined;
+  return hit ? [
+    issue("role-in-name", "warning", el, `${describe(el)} name "${name}" contains its role word "${hit}", announced twice`)
+  ] : [];
+});
+
+// ../../packages/e2e/src/a11y/rules/target-size.ts
+var WCAG_MIN = 24;
+var IOS_MIN = 44;
+var ANDROID_MIN = 48;
+var RADIUS = WCAG_MIN / 2;
+function targets(snapshot, ctx) {
+  const k = unitsPerPoint(snapshot);
+  return ctx.reachable.filter((el) => el.enabled && isActionable(el, ctx.platform) && el.frame.width > 0 && el.frame.height > 0).map((el) => ({ el, x: el.frame.x / k, y: el.frame.y / k, w: el.frame.width / k, h: el.frame.height / k }));
+}
+function centre(b) {
+  return { x: b.x + b.w / 2, y: b.y + b.h / 2 };
+}
+function distanceToBox(p, b) {
+  const dx = Math.max(b.x - p.x, 0, p.x - (b.x + b.w));
+  const dy = Math.max(b.y - p.y, 0, p.y - (b.y + b.h));
+  return Math.hypot(dx, dy);
+}
+var undersized = (b) => b.w < WCAG_MIN || b.h < WCAG_MIN;
+function wcagFailures(snapshot, ctx) {
+  const all = targets(snapshot, ctx);
+  return all.filter((b) => {
+    if (!undersized(b))
+      return false;
+    const c = centre(b);
+    return all.some((o) => {
+      if (related(b.el, o.el, ctx.parents))
+        return false;
+      if (undersized(o))
+        return Math.hypot(centre(o).x - c.x, centre(o).y - c.y) < RADIUS * 2;
+      return distanceToBox(c, o) < RADIUS;
+    });
+  });
+}
+var fmt = (n) => String(Math.round(n * 10) / 10);
+var targetSize = (snapshot, ctx) => {
+  const unit = ctx.platform === "ios" ? "pt" : "dp";
+  return wcagFailures(snapshot, ctx).map((b) => issue("target-size", "error", b.el, `${describe(b.el)} is ${fmt(b.w)}x${fmt(b.h)}${unit}, under ${WCAG_MIN}x${WCAG_MIN}${unit} with another target within ${WCAG_MIN}${unit}`, "2.5.8"));
+};
+var targetSizePlatform = (snapshot, ctx) => {
+  const min = ctx.platform === "ios" ? IOS_MIN : ANDROID_MIN;
+  const unit = ctx.platform === "ios" ? "pt" : "dp";
+  const failing = new Set(wcagFailures(snapshot, ctx).map((b) => b.el));
+  return targets(snapshot, ctx).filter((b) => (b.w < min || b.h < min) && !failing.has(b.el)).map((b) => issue("target-size-platform", "warning", b.el, `${describe(b.el)} is ${fmt(b.w)}x${fmt(b.h)}${unit}, under the platform minimum ${min}${unit}`));
+};
+
+// ../../packages/e2e/src/a11y/rules/text-clipped.ts
+var CLIPPING_MIN_SCALE = 1.6;
+var ELLIPSIS = /(\u2026|\.\.\.)$/;
+var TOLERANCE = 1;
+function overflows(el, parent) {
+  const f = el.frame;
+  const p = parent.frame;
+  return f.x < p.x - TOLERANCE || f.y < p.y - TOLERANCE || f.x + f.width > p.x + p.width + TOLERANCE || f.y + f.height > p.y + p.height + TOLERANCE;
+}
+var textClipped = (snapshot, ctx) => {
+  if (ctx.textScale === undefined || ctx.textScale < CLIPPING_MIN_SCALE)
+    return [];
+  return ctx.reachable.flatMap((el) => {
+    if (el.role !== "text")
+      return [];
+    const content = (el.text ?? el.label ?? el.value)?.trim();
+    if (content && ELLIPSIS.test(content))
+      return [issue("text-clipped", "warning", el, `${describe(el)} is truncated ("${content}")`, "1.4.4")];
+    const parent = ctx.parents.get(el);
+    if (!parent || parent.role === "scrollview" || parent.role === "list" || parent.traits.includes("scrollable"))
+      return [];
+    if (parent.frame.width >= snapshot.screen.width && parent.frame.height >= snapshot.screen.height)
+      return [];
+    return overflows(el, parent) ? [issue("text-clipped", "warning", el, `${describe(el)} overflows its container`, "1.4.4")] : [];
+  });
+};
+
+// ../../packages/e2e/src/a11y/audit.ts
+var WARDEN_RULES = [
+  { id: "missing-name", run: missingName },
+  { id: "image-no-name", run: imageNoName },
+  { id: "label-in-name", run: labelInName },
+  { id: "target-size", run: targetSize },
+  { id: "target-size-platform", run: targetSizePlatform },
+  { id: "duplicate-name", run: duplicateName },
+  { id: "role-in-name", run: roleInName },
+  { id: "hidden-focusable", run: hiddenFocusable },
+  { id: "text-clipped", run: textClipped }
+];
+function reachableNodes(snapshot) {
+  const reachable = [];
+  const parents = new Map;
+  const walk = (el, parent) => {
+    if (parent)
+      parents.set(el, parent);
+    if (el.hidden)
+      return;
+    if (el.a11y?.important !== false)
+      reachable.push(el);
+    for (const c of el.children)
+      walk(c, el);
+  };
+  for (const el of snapshot.elements)
+    walk(el, undefined);
+  return { reachable, parents };
+}
+var SEVERITY_RANK = { warning: 0, error: 1 };
+var ruleRank = (rule) => {
+  const i = WARDEN_RULES.findIndex((r) => r.id === rule);
+  return i === -1 ? WARDEN_RULES.length : i;
+};
+function positions(snapshot, platform) {
+  const listed = new Map;
+  readingOrder(snapshot, platform).forEach((a, i) => {
+    listed.set(a.id, i);
+  });
+  const pos = new Map;
+  let last = -1;
+  snapshot.flat.forEach((el, i) => {
+    const at = listed.get(el.id);
+    if (at !== undefined) {
+      pos.set(el.id, at);
+      last = at;
+    } else
+      pos.set(el.id, last + 0.5 + i / 1e6);
+  });
+  return pos;
+}
+function runAudit(snapshot, platform, opts = {}) {
+  const { reachable, parents } = reachableNodes(snapshot);
+  const resolved = opts.textSize === undefined ? undefined : resolveTextSize(opts.textSize);
+  const ctx = {
+    platform,
+    reachable,
+    parents,
+    ...resolved?.success ? { textScale: resolved.data.scale } : {}
+  };
+  const wanted = opts.rules === undefined ? undefined : new Set(opts.rules);
+  const found = WARDEN_RULES.filter((r) => wanted === undefined || wanted.has(r.id)).flatMap((r) => r.run(snapshot, ctx));
+  const ignore = opts.ignore ?? [];
+  const kept = found.filter((i) => !ignore.some((g) => g.rule === i.rule && (g.identifier === undefined || g.identifier === i.identifier)));
+  const seen = new Set;
+  const unique = kept.filter((i) => {
+    const k = `${i.rule}\x00${i.elementId ?? ""}\x00${i.message}`;
+    if (seen.has(k))
+      return false;
+    seen.add(k);
+    return true;
+  });
+  const pos = positions(snapshot, platform);
+  const at = (i) => i.elementId === undefined ? Number.MAX_SAFE_INTEGER : pos.get(i.elementId) ?? 0;
+  const issues = unique.sort((a, b) => at(a) - at(b) || ruleRank(a.rule) - ruleRank(b.rule));
+  return { issues, checked: reachable.length, sources: ["warden"], skipped: [] };
+}
+function failing(result, minSeverity = "error") {
+  return result.issues.filter((i) => SEVERITY_RANK[i.severity] >= SEVERITY_RANK[minSeverity]);
+}
+function elementKey(i) {
+  return i.identifier ?? i.elementId;
+}
+function mergeIssues(base, extra, skipped = []) {
+  const issues = [...base.issues];
+  const added = [];
+  for (const e of extra) {
+    const key = elementKey(e);
+    const idx = issues.findIndex((i) => key !== undefined && elementKey(i) === key && (e.wcag !== undefined ? i.wcag === e.wcag : i.rule === e.rule && i.message === e.message));
+    const hit = idx === -1 ? undefined : issues[idx];
+    if (hit === undefined) {
+      added.push(e);
+    } else if (hit.source !== e.source && !hit.message.includes(`also reported by ${e.source}`)) {
+      issues[idx] = { ...hit, message: `${hit.message} (also reported by ${e.source})` };
+    }
+  }
+  const sources = [...new Set([...base.sources, ...extra.map((e) => e.source)])];
+  return {
+    issues: [...issues, ...added],
+    checked: base.checked,
+    sources,
+    skipped: [...base.skipped, ...skipped]
+  };
+}
+function formatIssues(result, minSeverity = "warning") {
+  const shown = failing(result, minSeverity);
+  const head = `a11y audit: ${shown.length} issue${shown.length === 1 ? "" : "s"} in ${result.checked} elements (${result.sources.join(", ")})`;
+  const skipped = result.skipped.map((s) => `skipped ${s.source}: ${s.reason}`);
+  if (shown.length === 0)
+    return [head, ...skipped].join(`
+`);
+  const rows = shown.map((i) => [i.severity, i.rule, i.wcag ?? "-", i.identifier ?? i.elementId ?? "-", i.message]);
+  const widths = [0, 1, 2, 3].map((c) => Math.max(...rows.map((r) => r[c]?.length ?? 0)));
+  const lines = rows.map((r) => `${r.map((cell, c) => c < 4 ? cell.padEnd(widths[c] ?? 0) : cell).join("  ")}`);
+  return [head, ...lines, ...skipped].join(`
+`);
+}
+
+// ../../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",
+  "E_DEVICE_LOCKED"
+]);
+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 aborted2(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 aborted2(action, signal);
+  let onAbort;
+  const abort = new Promise((_, reject) => {
+    onAbort = () => reject(aborted2(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/driver/a11y-events.ts
+function canReadA11yEvents(driver) {
+  return typeof driver.a11yEvents === "function";
+}
+var KINDS = new Set([
+  "announcement",
+  "live-region",
+  "screen-changed",
+  "layout-changed"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var SYSTEM_ANNOUNCEMENT = /^AXAnnouncementType/;
+function parseA11yEvent(value, source) {
+  if (!isRecord(value) || typeof value.kind !== "string" || !KINDS.has(value.kind))
+    return;
+  if (typeof value.at !== "number" || !Number.isFinite(value.at))
+    return;
+  if (value.text !== undefined && typeof value.text !== "string")
+    return;
+  return {
+    kind: value.kind,
+    ...typeof value.text === "string" && value.text !== "" ? { text: value.text } : {},
+    at: value.at,
+    source
+  };
+}
+function parseUiadA11yEvents(data) {
+  if (!isRecord(data) || !Array.isArray(data.events) || typeof data.cursor !== "number") {
+    return { success: false, error: "warden-uiad answered a11yEvents with an unexpected shape" };
+  }
+  const events = [];
+  for (const [index, raw] of data.events.entries()) {
+    const event = parseA11yEvent(raw, "uiad");
+    if (!event)
+      return { success: false, error: `warden-uiad sent a malformed a11y event at ${index}` };
+    events.push(event);
+  }
+  return { success: true, data: { events, cursor: data.cursor, ...data.lost === true ? { lost: true } : {} } };
+}
+function parseInjectEvents(text, since = 0) {
+  const bytes = Buffer.from(text, "utf8");
+  const start = since > bytes.length || since < 0 ? 0 : since;
+  const end = bytes.lastIndexOf(10) + 1;
+  if (end <= start)
+    return { events: [], cursor: start };
+  const events = [];
+  for (const line of bytes.subarray(start, end).toString("utf8").split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    try {
+      const event = parseA11yEvent(JSON.parse(line), "inject");
+      if (event && !(event.text !== undefined && SYSTEM_ANNOUNCEMENT.test(event.text)))
+        events.push(event);
+    } catch {}
+  }
+  return { events, cursor: end };
+}
+
+// ../../packages/e2e/src/a11y/announcements.ts
+var ANNOUNCEMENT_TIMEOUT_MS = 5000;
+var ANNOUNCEMENT_POLL_MS = 100;
+var ANNOUNCING = new Set(["announcement", "live-region"]);
+function matches(event, match) {
+  if (!ANNOUNCING.has(event.kind) || event.text === undefined)
+    return false;
+  if (typeof match === "string")
+    return event.text.includes(match);
+  match.lastIndex = 0;
+  return match.test(event.text);
+}
+function withDefaults(opts) {
+  return {
+    now: opts.now ?? Date.now,
+    sleep: opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    timeoutMs: opts.timeoutMs ?? ANNOUNCEMENT_TIMEOUT_MS,
+    pollMs: opts.pollMs ?? ANNOUNCEMENT_POLL_MS
+  };
+}
+async function waitForAnnouncement(driver, match, opts = {}) {
+  if (!canReadA11yEvents(driver)) {
+    return {
+      success: false,
+      error: driverError("E_UNSUPPORTED", "this driver cannot read announcements (no a11yEvents capability)")
+    };
+  }
+  const { now, sleep, timeoutMs, pollMs } = withDefaults(opts);
+  const deadline = now() + timeoutMs;
+  let cursor = opts.since;
+  const seen = [];
+  for (;; ) {
+    const read = await driver.a11yEvents(cursor);
+    if (!read.success)
+      return read;
+    cursor = read.data.cursor;
+    const hit = read.data.events.find((event) => matches(event, match));
+    if (hit)
+      return { success: true, data: { event: hit, cursor: read.data.cursor } };
+    for (const event of read.data.events)
+      if (event.text !== undefined)
+        seen.push(event.text);
+    if (now() >= deadline) {
+      return {
+        success: false,
+        error: driverError("E_TIMEOUT", `no announcement matched ${String(match)} within ${timeoutMs} ms`, {
+          detail: { seen: seen.slice(-10), cursor }
+        })
+      };
+    }
+    await sleep(pollMs);
+  }
+}
+
+// ../../packages/e2e/src/driver/a11y-read.ts
+function canReadA11y(driver) {
+  return typeof driver.readA11y === "function";
+}
+
+// ../../packages/e2e/src/driver/native-audit.ts
+function canAuditNatively(driver) {
+  return typeof driver.auditNatively === "function";
+}
+
+// ../../packages/e2e/src/driver/screen-reader.ts
+function canDriveScreenReader(driver) {
+  return typeof driver.screenReaderNext === "function";
+}
+
+// ../../packages/e2e/src/device-a11y.ts
+var TALKBACK_HINT = "turn TalkBack on with device.a11y({ screenReader: true }) on an Android emulator";
+function unsupported(action, why) {
+  return toE2eError(driverError("E_UNSUPPORTED", why), action);
+}
+async function withA11yRead(driver, snapshot) {
+  if (!canReadA11y(driver))
+    return { success: true, data: snapshot };
+  const read = await driver.readA11y(snapshot);
+  if (read.success)
+    return read;
+  if (read.error.code === "E_UNSUPPORTED")
+    return { success: true, data: snapshot };
+  return read;
+}
+var A11Y_EXCERPT_LINES = 40;
+function renderA11yScreen(snapshot, maxLines = A11Y_EXCERPT_LINES) {
+  const rendered = renderSnapshot(snapshot, { interactiveOnly: true, refs: new Map, a11y: true, maxLines });
+  return [renderHeader({ snapshot, rendered, interactiveOnly: true }), ...rendered.lines].join(`
+`);
+}
+function ignored(issue, ignore) {
+  return ignore.some((g) => g.rule === issue.rule && (g.identifier === undefined || g.identifier === issue.identifier));
+}
+async function auditSnapshot(driver, snapshot, options = {}) {
+  const { platform } = driver;
+  const { rules, minSeverity } = options;
+  const ignore = options.ignore ?? [];
+  const own = runAudit(snapshot, platform, {
+    ...rules === undefined ? {} : { rules },
+    ignore,
+    ...minSeverity === undefined ? {} : { minSeverity },
+    ...options.textSize === undefined ? {} : { textSize: options.textSize }
+  });
+  if (options.native === false || rules !== undefined && !rules.includes("native"))
+    return own;
+  const source = platform === "ios" ? "xcuitest" : "atf";
+  if (!canAuditNatively(driver)) {
+    return mergeIssues(own, [], [{ source, reason: "this driver has no native accessibility audit" }]);
+  }
+  const native = await driver.auditNatively(options.bundleId === undefined ? {} : { bundleId: options.bundleId });
+  return mergeIssues(own, native.issues.filter((issue) => !ignored(issue, ignore)), native.skipped === undefined ? [] : [native.skipped]);
+}
+function createDeviceA11y(deps) {
+  const { driver, env } = deps;
+  const signal = () => deps.signal();
+  const { platform } = driver;
+  const readSnapshot = async () => {
+    const snapshot = await unwrap(() => driver.snapshot(), "snapshot", signal());
+    const merged = await withA11yRead(driver, snapshot);
+    if (!merged.success)
+      throw toE2eError(merged.error, "read accessibility facts");
+    return merged.data;
+  };
+  const audit = async (options = {}) => {
+    const config = env.a11yAudit ?? {};
+    const rules = options.rules ?? config.rules;
+    const ignore = options.ignore ?? config.ignore ?? [];
+    const minSeverity = options.minSeverity ?? config.minSeverity;
+    return auditSnapshot(driver, await readSnapshot(), {
+      ...rules === undefined ? {} : { rules },
+      ignore,
+      ...minSeverity === undefined ? {} : { minSeverity },
+      ...options.textSize === undefined ? {} : { textSize: options.textSize },
+      ...options.native === undefined ? {} : { native: options.native },
+      ...env.bundleId === undefined ? {} : { bundleId: env.bundleId }
+    });
+  };
+  const announcements = async (options = {}) => {
+    if (!canReadA11yEvents(driver)) {
+      throw unsupported("device.announcements", "this driver cannot read announcements (no a11yEvents capability)");
+    }
+    const { since } = options;
+    const read = await unwrap(() => driver.a11yEvents(since), "read announcements", signal());
+    const announced = read.events.filter((e) => (e.kind === "announcement" || e.kind === "live-region") && e.text !== undefined);
+    return {
+      announcements: announced.map((e) => ({ kind: e.kind, text: e.text, at: e.at, source: e.source })),
+      cursor: read.cursor,
+      ...read.lost === true ? { lost: true } : {}
+    };
+  };
+  const reader = (action) => {
+    if (!canDriveScreenReader(driver))
+      throw unsupported(action, TALKBACK_HINT);
+    return driver;
+  };
+  const spoken = (el) => el === undefined ? undefined : announce(el, platform);
+  const screenReader = {
+    async order() {
+      return readingOrder(await readSnapshot(), platform);
+    },
+    async state() {
+      const d = reader("device.screenReader.state");
+      return unwrap(() => d.screenReaderState(), "screen reader state", signal());
+    },
+    async next() {
+      const d = reader("device.screenReader.next");
+      return spoken(await unwrap(() => d.screenReaderNext(), "screen reader next", signal()));
+    },
+    async prev() {
+      const d = reader("device.screenReader.prev");
+      return spoken(await unwrap(() => d.screenReaderPrev(), "screen reader prev", signal()));
+    },
+    async activate() {
+      const d = reader("device.screenReader.activate");
+      await unwrap(() => d.screenReaderActivate(), "screen reader activate", signal());
+    },
+    async focused() {
+      const d = reader("device.screenReader.focused");
+      return spoken(await unwrap(() => d.screenReaderFocused(), "screen reader focused", signal()));
+    },
+    async spoken(options = {}) {
+      const d = reader("device.screenReader.spoken");
+      const read = await unwrap(() => d.screenReaderSpoken(options.since), "screen reader spoken", signal());
+      return { lines: read.lines, cursor: read.cursor };
+    }
+  };
+  const target = {
+    audit: (options) => audit(options),
+    waitForAnnouncement(match, options) {
+      return waitForAnnouncement(driver, match, {
+        timeoutMs: options.timeoutMs,
+        ...options.since === undefined ? {} : { since: options.since }
+      });
+    },
+    async a11yScreen() {
+      const taken = await settled(() => driver.snapshot(), "snapshot", signal());
+      if (!taken.success)
+        return;
+      const merged = await withA11yRead(driver, taken.data);
+      return renderA11yScreen(merged.success ? merged.data : taken.data);
+    },
+    assertionTimeout: () => env.assertionTimeoutMs,
+    step: (label, fn) => deps.step === undefined ? fn() : deps.step(label, fn)
+  };
+  return { a11yAudit: audit, screenReader, announcements, target };
+}
+
+// ../../packages/e2e/src/driver/ios/device/capabilities.ts
+var IOS_DEVICE_CAPABILITIES = {
+  pinch: false,
+  maxPointers: 0,
+  unicodeText: true,
+  nativeSettle: false,
+  alerts: true,
+  reachability: true,
+  cheapHitTest: false
+};
+
+// ../../packages/e2e/src/conditions/device-conditions.ts
+import { dirname as dirname5, resolve as resolve3 } from "path";
+
+// ../../packages/core/src/conditions/camera-media.ts
+import { createHash } from "crypto";
+import { closeSync, copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, openSync, readFileSync, readSync, rmSync } from "fs";
+import { join as join3 } from "path";
+var SUPPORTED = "png, jpg, heic, mp4, mov";
+var FTYP_BRANDS = {
+  heic: { kind: "image", ext: "heic" },
+  heix: { kind: "image", ext: "heic" },
+  mif1: { kind: "image", ext: "heic" },
+  "qt  ": { kind: "video", ext: "mov" },
+  isom: { kind: "video", ext: "mp4" },
+  iso2: { kind: "video", ext: "mp4" },
+  mp41: { kind: "video", ext: "mp4" },
+  mp42: { kind: "video", ext: "mp4" },
+  avc1: { kind: "video", ext: "mp4" },
+  M4V: { kind: "video", ext: "mp4" },
+  "M4V ": { kind: "video", ext: "mp4" }
+};
+function head2(path, n) {
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(n);
+    const read = readSync(fd, buf, 0, n, 0);
+    return buf.subarray(0, read);
+  } finally {
+    closeSync(fd);
+  }
+}
+function sniffCameraMedia(path) {
+  if (!existsSync3(path)) {
+    return { success: false, error: { code: "E_CAMERA_NOT_FOUND", message: `camera media not found: ${path}` } };
+  }
+  const b = head2(path, 12);
+  if (b.length >= 8 && b.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return ok({ kind: "image", ext: "png" });
+  }
+  if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255)
+    return ok({ kind: "image", ext: "jpg" });
+  if (b.length >= 12 && b.subarray(4, 8).toString("latin1") === "ftyp") {
+    const brand = FTYP_BRANDS[b.subarray(8, 12).toString("latin1")];
+    if (brand)
+      return ok(brand);
+  }
+  return {
+    success: false,
+    error: { code: "E_CAMERA_MEDIA", message: `unsupported camera media ${path}: use ${SUPPORTED}` }
+  };
+}
+function cameraFeedDir(wardenHome, udid) {
+  return join3(wardenHome, "camera", udid);
+}
+function stageCameraFeed(input) {
+  const sniffed = sniffCameraMedia(input.source);
+  if (!sniffed.success)
+    return sniffed;
+  const hash = createHash("sha256").update(readFileSync(input.source)).digest("hex").slice(0, 12);
+  const dir = cameraFeedDir(input.wardenHome, input.udid);
+  mkdirSync3(dir, { recursive: true });
+  const path = join3(dir, `${input.facing}-${hash}.${sniffed.data.ext}`);
+  if (!existsSync3(path))
+    copyFileSync(input.source, path);
+  return ok(sniffed.data.kind === "image" ? { kind: "image", path } : { kind: "video", path, loop: input.loop });
+}
+function clearCameraFeeds(wardenHome, udid) {
+  rmSync(cameraFeedDir(wardenHome, udid), { recursive: true, force: true });
+}
+
+// ../../packages/core/src/store.ts
+import { Database } from "bun:sqlite";
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+
+// ../../packages/core/src/lease-events.ts
+var LEASE_EVENT_TYPES = [
+  "requested",
+  "queued",
+  "granted",
+  "heartbeat_lost",
+  "released",
+  "expired",
+  "evicted",
+  "quarantined",
+  "unquarantined",
+  "shutdown",
+  "device_unhealthy",
+  "device_recovered"
+];
+function insertLeaseEvent(db, event) {
+  db.query(`INSERT INTO lease_events (at, type, lease_id, resource_key, owner_key, label, claim_id, data)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(event.at, event.type, event.leaseId ?? null, event.resourceKey ?? null, event.ownerKey ?? null, event.label ?? null, event.claimId ?? null, JSON.stringify(event.data));
+}
+function isEventType(value) {
+  return LEASE_EVENT_TYPES.includes(value);
+}
+function toEvent(row) {
+  if (!isEventType(row.type))
+    return;
+  const base = {
+    id: row.id,
+    at: row.at,
+    type: row.type,
+    data: JSON.parse(row.data),
+    ...row.lease_id !== null ? { leaseId: row.lease_id } : {},
+    ...row.resource_key !== null ? { resourceKey: row.resource_key } : {},
+    ...row.owner_key !== null ? { ownerKey: row.owner_key } : {},
+    ...row.label !== null ? { label: row.label } : {},
+    ...row.claim_id !== null ? { claimId: row.claim_id } : {}
+  };
+  return base;
+}
+function queryLeaseEvents(db, filter = {}) {
+  const where = [];
+  const params = [];
+  if (filter.since !== undefined) {
+    where.push("at >= ?");
+    params.push(filter.since);
+  }
+  if (filter.leaseId !== undefined) {
+    where.push("lease_id = ?");
+    params.push(filter.leaseId);
+  }
+  if (filter.owner !== undefined) {
+    where.push("instr(owner_key, ?) > 0");
+    params.push(filter.owner);
+  }
+  if (filter.afterId !== undefined) {
+    where.push("id > ?");
+    params.push(filter.afterId);
+  }
+  const sql = `SELECT * FROM lease_events${where.length > 0 ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY id`;
+  return db.query(sql).all(...params).flatMap((row) => toEvent(row) ?? []);
+}
+function pruneLeaseEvents(db, before) {
+  return db.query("DELETE FROM lease_events WHERE at < ?").run(before).changes;
+}
+var INTERNAL_LEASE_LABELS = ["capacity-evict", "gc-shutdown", "reclaiming"];
+
+// ../../packages/core/src/liveness.ts
+var LOST_HEARTBEATS = 3;
+function isLeaseAlive(lease, now, pidAlive) {
+  const supervised = lease.pid !== undefined && lease.heartbeatMs !== undefined;
+  const fresh = supervised ? Math.min(lease.ttlMs, LOST_HEARTBEATS * (lease.heartbeatMs ?? 0)) : lease.ttlMs;
+  if (now - lease.heartbeatAt <= fresh)
+    return true;
+  return lease.pid !== undefined && pidAlive(lease.pid);
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+
+// ../../packages/core/src/queue.ts
+var AGING_MS = 10 * 60000;
+var DEVICE_WAIT_REASONS = ["device-limit", "requester-limit", "waiting-for-device"];
+var WAIT_REASONS = new Set([
+  "behind-earlier",
+  "ram-budget",
+  "cpu-budget",
+  "memory-pressure",
+  "host-load",
+  ...DEVICE_WAIT_REASONS
+]);
+var isWaitReason = (s) => WAIT_REASONS.has(s);
+
+// ../../packages/core/src/types.ts
+function resourceKey(resource) {
+  switch (resource.kind) {
+    case "device":
+      return `device:${resource.platform}:${resource.id}`;
+    case "port":
+      return `port:${resource.port}`;
+    case "build":
+      return `build:${resource.key}`;
+  }
+}
+function describeOwner(owner) {
+  switch (owner.kind) {
+    case "agent":
+      return `agent ${owner.sessionId}`;
+    case "user":
+      return `user pid ${owner.pid}`;
+    case "ci":
+      return `ci ${owner.runId}`;
+  }
+}
+var PHYSICAL_IOS_ID = /^(?:[0-9A-F]{8}-[0-9A-F]{16}|[0-9a-f]{40})$/i;
+function isPhysicalIosId(id) {
+  return PHYSICAL_IOS_ID.test(id);
+}
+
+// ../../packages/core/src/store.ts
+function wardenHome(env = process.env) {
+  if (env.WARDEN_HOME)
+    return env.WARDEN_HOME;
+  return join4(env.HOME ?? "~", ".warden");
+}
+function defaultDbPath(env = process.env) {
+  return join4(wardenHome(env), "warden.db");
+}
+var MIGRATIONS = [
+  `CREATE TABLE leases (
+		id TEXT PRIMARY KEY,
+		resource_key TEXT NOT NULL UNIQUE,
+		resource TEXT NOT NULL,
+		owner_key TEXT NOT NULL,
+		owner TEXT NOT NULL,
+		label TEXT,
+		acquired_at INTEGER NOT NULL,
+		heartbeat_at INTEGER NOT NULL,
+		ttl_ms INTEGER NOT NULL,
+		pid INTEGER
+	);
+	CREATE INDEX leases_owner ON leases(owner_key);
+	CREATE TABLE devices (
+		platform TEXT NOT NULL,
+		id TEXT NOT NULL,
+		name TEXT NOT NULL,
+		profile TEXT,
+		runtime TEXT,
+		created_at INTEGER NOT NULL,
+		last_used_at INTEGER NOT NULL,
+		PRIMARY KEY (platform, id)
+	);`,
+  `CREATE TABLE builds (
+		project_key TEXT NOT NULL,
+		platform TEXT NOT NULL,
+		profile TEXT NOT NULL,
+		hash TEXT NOT NULL,
+		path TEXT NOT NULL,
+		source TEXT NOT NULL,
+		size INTEGER NOT NULL,
+		created_at INTEGER NOT NULL,
+		last_used_at INTEGER NOT NULL,
+		PRIMARY KEY (project_key, platform, hash)
+	);
+	CREATE TABLE installs (
+		platform TEXT NOT NULL,
+		device_id TEXT NOT NULL,
+		bundle_id TEXT NOT NULL,
+		hash TEXT NOT NULL,
+		installed_at INTEGER NOT NULL,
+		PRIMARY KEY (platform, device_id, bundle_id)
+	);`,
+  `ALTER TABLE leases ADD COLUMN booted_by_owner INTEGER;
+	CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);`,
+  `ALTER TABLE devices ADD COLUMN quarantined_at INTEGER;
+	ALTER TABLE devices ADD COLUMN quarantine_reason TEXT;
+	ALTER TABLE devices ADD COLUMN slimmed_at INTEGER;`,
+  `ALTER TABLE leases ADD COLUMN heartbeat_ms INTEGER;`,
+  `CREATE TABLE fingerprints (
+		root TEXT NOT NULL,
+		platform TEXT NOT NULL,
+		variant TEXT NOT NULL,
+		command TEXT NOT NULL,
+		signature TEXT NOT NULL,
+		native TEXT NOT NULL,
+		computed_at INTEGER NOT NULL,
+		PRIMARY KEY (root, platform, variant, command)
+	);`,
+  `ALTER TABLE installs ADD COLUMN container TEXT;
+	ALTER TABLE installs ADD COLUMN exe_stamp TEXT;`,
+  `CREATE TABLE boot_queue (
+		id TEXT PRIMARY KEY,
+		platform TEXT NOT NULL,
+		profile TEXT NOT NULL,
+		units REAL NOT NULL,
+		priority INTEGER NOT NULL,
+		enqueued_at INTEGER NOT NULL,
+		heartbeat_at INTEGER NOT NULL,
+		owner_key TEXT NOT NULL,
+		owner TEXT NOT NULL,
+		label TEXT,
+		pid INTEGER
+	);
+	CREATE INDEX boot_queue_order ON boot_queue(priority, enqueued_at);`,
+  `ALTER TABLE leases ADD COLUMN shared INTEGER;`,
+  `ALTER TABLE builds ADD COLUMN kind TEXT NOT NULL DEFAULT 'legacy';
+	ALTER TABLE builds ADD COLUMN base_hash TEXT;
+	ALTER TABLE builds ADD COLUMN js_key TEXT;
+	ALTER TABLE builds ADD COLUMN worktree TEXT;
+	ALTER TABLE builds ADD COLUMN branch TEXT;`,
+  `CREATE TABLE lease_conditions (
+		lease_id TEXT NOT NULL REFERENCES leases(id) ON DELETE CASCADE,
+		area TEXT NOT NULL,
+		json TEXT NOT NULL,
+		owned TEXT NOT NULL DEFAULT '[]',
+		set_at INTEGER NOT NULL,
+		PRIMARY KEY (lease_id, area)
+	);`,
+  `CREATE TABLE orphan_conditions (
+		platform TEXT NOT NULL,
+		device_id TEXT NOT NULL,
+		area TEXT NOT NULL,
+		lease_id TEXT NOT NULL,
+		json TEXT NOT NULL,
+		owned TEXT NOT NULL DEFAULT '[]',
+		set_at INTEGER NOT NULL,
+		orphaned_at INTEGER NOT NULL,
+		PRIMARY KEY (platform, device_id, area)
+	);
+	CREATE TRIGGER leases_orphan_conditions BEFORE DELETE ON leases
+	WHEN json_extract(OLD.resource, '$.kind') = 'device' AND json_extract(OLD.resource, '$.id') NOT LIKE 'pending:%'
+	BEGIN
+		INSERT OR REPLACE INTO orphan_conditions (platform, device_id, area, lease_id, json, owned, set_at, orphaned_at)
+		SELECT json_extract(OLD.resource, '$.platform'), json_extract(OLD.resource, '$.id'), c.area, OLD.id, c.json, c.owned, c.set_at,
+			CAST(strftime('%s', 'now') AS INTEGER) * 1000
+		FROM lease_conditions c WHERE c.lease_id = OLD.id;
+	END;`,
+  `ALTER TABLE devices ADD COLUMN persistent_at INTEGER;`,
+  `ALTER TABLE boot_queue ADD COLUMN reason TEXT;`,
+  `ALTER TABLE leases ADD COLUMN claim_id TEXT;
+	ALTER TABLE boot_queue ADD COLUMN claim_id TEXT;`,
+  `CREATE TABLE lease_events (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		at INTEGER NOT NULL,
+		type TEXT NOT NULL,
+		lease_id TEXT,
+		resource_key TEXT,
+		owner_key TEXT,
+		label TEXT,
+		claim_id TEXT,
+		data TEXT NOT NULL DEFAULT '{}'
+	);
+	CREATE INDEX lease_events_at ON lease_events(at);
+	CREATE INDEX lease_events_lease ON lease_events(lease_id);
+	CREATE INDEX lease_events_owner ON lease_events(owner_key, at);
+	CREATE INDEX lease_events_claim ON lease_events(claim_id);`,
+  `CREATE TABLE claim_keys (
+		owner_key TEXT NOT NULL,
+		key TEXT NOT NULL,
+		claim_id TEXT NOT NULL,
+		platform TEXT NOT NULL,
+		profile TEXT NOT NULL,
+		count INTEGER NOT NULL,
+		ready INTEGER NOT NULL DEFAULT 0,
+		created_at INTEGER NOT NULL,
+		PRIMARY KEY (owner_key, key)
+	);
+	CREATE INDEX claim_keys_claim ON claim_keys(claim_id);`
+];
+var QUEUE_TTL_MS = 60000;
+function ownerKey(owner) {
+  switch (owner.kind) {
+    case "agent":
+      return `agent:${owner.sessionId}`;
+    case "user":
+      return `user:${owner.pid}`;
+    case "ci":
+      return `ci:${owner.runId}`;
+  }
+}
+function toQueueEntry(row) {
+  const entry = {
+    id: row.id,
+    platform: row.platform,
+    profile: row.profile,
+    units: row.units,
+    priority: row.priority,
+    enqueuedAt: row.enqueued_at,
+    heartbeatAt: row.heartbeat_at,
+    owner: JSON.parse(row.owner)
+  };
+  if (row.label !== null)
+    entry.label = row.label;
+  if (row.pid !== null)
+    entry.pid = row.pid;
+  if (row.reason !== null && isWaitReason(row.reason))
+    entry.reason = row.reason;
+  if (row.claim_id !== null)
+    entry.claimId = row.claim_id;
+  return entry;
+}
+function toLease(row) {
+  const lease = {
+    id: row.id,
+    resource: JSON.parse(row.resource),
+    owner: JSON.parse(row.owner),
+    acquiredAt: row.acquired_at,
+    heartbeatAt: row.heartbeat_at,
+    ttlMs: row.ttl_ms
+  };
+  if (row.label !== null)
+    lease.label = row.label;
+  if (row.pid !== null)
+    lease.pid = row.pid;
+  if (row.booted_by_owner)
+    lease.bootedByOwner = true;
+  if (row.heartbeat_ms !== null)
+    lease.heartbeatMs = row.heartbeat_ms;
+  if (row.shared)
+    lease.shared = true;
+  if (row.claim_id !== null)
+    lease.claimId = row.claim_id;
+  return lease;
+}
+function toDevice(row) {
+  const device = {
+    platform: row.platform,
+    id: row.id,
+    name: row.name,
+    createdAt: row.created_at,
+    lastUsedAt: row.last_used_at
+  };
+  if (row.profile !== null)
+    device.profile = row.profile;
+  if (row.runtime !== null)
+    device.runtime = row.runtime;
+  if (row.quarantined_at !== null)
+    device.quarantinedAt = row.quarantined_at;
+  if (row.quarantine_reason !== null)
+    device.quarantineReason = row.quarantine_reason;
+  if (row.slimmed_at !== null)
+    device.slimmedAt = row.slimmed_at;
+  if (row.persistent_at !== null)
+    device.persistentAt = row.persistent_at;
+  return device;
+}
+function newLeaseId() {
+  return `l_${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+}
+
+class Store {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  close() {
+    this.db.close();
+  }
+  transaction(fn) {
+    if (this.db.inTransaction)
+      return fn();
+    return this.db.transaction(fn).immediate();
+  }
+  insertLease(input, now) {
+    const lease = {
+      id: newLeaseId(),
+      resource: input.resource,
+      owner: input.owner,
+      acquiredAt: now,
+      heartbeatAt: now,
+      ttlMs: input.ttlMs
+    };
+    if (input.label !== undefined)
+      lease.label = input.label;
+    if (input.pid !== undefined)
+      lease.pid = input.pid;
+    if (input.bootedByOwner)
+      lease.bootedByOwner = true;
+    if (input.shared)
+      lease.shared = true;
+    if (input.claimId !== undefined)
+      lease.claimId = input.claimId;
+    this.db.query(`INSERT INTO leases (id, resource_key, resource, owner_key, owner, label, acquired_at, heartbeat_at, ttl_ms, pid, booted_by_owner, shared, claim_id)
+				 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(lease.id, resourceKey(lease.resource), JSON.stringify(lease.resource), ownerKey(lease.owner), JSON.stringify(lease.owner), lease.label ?? null, now, now, lease.ttlMs, lease.pid ?? null, lease.bootedByOwner ? 1 : null, lease.shared ? 1 : null, lease.claimId ?? null);
+    return lease;
+  }
+  markShared(ids) {
+    if (ids.length === 0)
+      return;
+    const stmt = this.db.query("UPDATE leases SET shared = 1 WHERE id = ?");
+    this.transaction(() => {
+      for (const id of ids)
+        stmt.run(id);
+    });
+  }
+  markBootedByOwner(id) {
+    this.db.query("UPDATE leases SET booted_by_owner = 1 WHERE id = ?").run(id);
+  }
+  setLeasePid(id, pid) {
+    this.db.query("UPDATE leases SET pid = ? WHERE id = ?").run(pid, id);
+  }
+  getMeta(key) {
+    return this.db.query("SELECT value FROM meta WHERE key = ?").get(key)?.value;
+  }
+  setMeta(key, value) {
+    this.db.query("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
+  deleteMeta(key) {
+    this.db.query("DELETE FROM meta WHERE key = ?").run(key);
+  }
+  getLease(id) {
+    const row = this.db.query("SELECT * FROM leases WHERE id = ?").get(id);
+    return row ? toLease(row) : undefined;
+  }
+  listLeases() {
+    return this.db.query("SELECT * FROM leases ORDER BY acquired_at, id").all().map(toLease);
+  }
+  listLeasesByOwner(owner) {
+    return this.db.query("SELECT * FROM leases WHERE owner_key = ? ORDER BY acquired_at, id").all(ownerKey(owner)).map(toLease);
+  }
+  findLeaseByResource(resource) {
+    const row = this.db.query("SELECT * FROM leases WHERE resource_key = ?").get(resourceKey(resource));
+    return row ? toLease(row) : undefined;
+  }
+  deleteLeases(ids, end) {
+    if (ids.length === 0)
+      return 0;
+    const stmt = this.db.query("DELETE FROM leases WHERE id = ?");
+    return this.transaction(() => ids.reduce((n, id) => {
+      const lease = end ? this.getLease(id) : undefined;
+      const changes = stmt.run(id).changes;
+      if (changes > 0 && lease && end)
+        this.recordLeaseEnd(lease, end);
+      return n + changes;
+    }, 0));
+  }
+  recordLeaseEnd(lease, end) {
+    if (lease.resource.kind !== "device" || lease.resource.id.startsWith("pending:"))
+      return;
+    if (lease.label !== undefined && INTERNAL_LEASE_LABELS.includes(lease.label))
+      return;
+    const granted = this.db.query("SELECT at FROM lease_events WHERE lease_id = ? AND type = 'granted' LIMIT 1").get(lease.id);
+    if (!granted)
+      return;
+    this.recordEvent({
+      at: end.now,
+      type: end.type,
+      data: { heldMs: Math.max(0, end.now - granted.at) },
+      leaseId: lease.id,
+      resourceKey: resourceKey(lease.resource),
+      ownerKey: ownerKey(lease.owner),
+      ...lease.label !== undefined ? { label: lease.label } : {},
+      ...lease.claimId !== undefined ? { claimId: lease.claimId } : {}
+    });
+  }
+  recordEvent(event) {
+    insertLeaseEvent(this.db, event);
+  }
+  recordQueuedOnce(event) {
+    return this.transaction(() => {
+      const seen = this.db.query("SELECT 1 AS n FROM lease_events WHERE type = 'queued' AND claim_id IS ?1 AND json_extract(data, '$.queueId') = ?2 LIMIT 1").get(event.claimId ?? null, event.data.queueId);
+      if (seen)
+        return false;
+      this.recordEvent(event);
+      return true;
+    });
+  }
+  recordHeartbeatLost(ids, now) {
+    return this.transaction(() => {
+      let logged = 0;
+      for (const id of ids) {
+        const event = this.getLease(id) ? undefined : this.heartbeatLostEvent(id, now);
+        if (!event)
+          continue;
+        this.recordEvent(event);
+        logged++;
+      }
+      return logged;
+    });
+  }
+  heartbeatLostEvent(leaseId, at) {
+    const granted = this.db.query("SELECT resource_key, owner_key, label, claim_id FROM lease_events WHERE lease_id = ? AND type = 'granted' LIMIT 1").get(leaseId);
+    if (!granted)
+      return;
+    return {
+      at,
+      type: "heartbeat_lost",
+      data: {},
+      leaseId,
+      ...granted.resource_key ? { resourceKey: granted.resource_key } : {},
+      ...granted.owner_key ? { ownerKey: granted.owner_key } : {},
+      ...granted.label ? { label: granted.label } : {},
+      ...granted.claim_id ? { claimId: granted.claim_id } : {}
+    };
+  }
+  listEvents(filter = {}) {
+    return queryLeaseEvents(this.db, filter);
+  }
+  pruneEvents(before) {
+    return pruneLeaseEvents(this.db, before);
+  }
+  heartbeat(ids, now, periodMs) {
+    if (ids.length === 0)
+      return 0;
+    const stmt = this.db.query("UPDATE leases SET heartbeat_at = ?, heartbeat_ms = COALESCE(?, heartbeat_ms) WHERE id = ?");
+    return this.transaction(() => ids.reduce((n, id) => n + stmt.run(now, periodMs ?? null, id).changes, 0));
+  }
+  reclaimStale(now, pidAlive) {
+    return this.transaction(() => {
+      const stale = this.listLeases().filter((l) => !isLeaseAlive(l, now, pidAlive)).map((l) => l.id);
+      this.deleteLeases(stale, { type: "expired", now });
+      return stale;
+    });
+  }
+  enqueue(entry) {
+    return this.transaction(() => {
+      this.db.query(`INSERT INTO boot_queue (id, platform, profile, units, priority, enqueued_at, heartbeat_at, owner_key, owner, label, pid, reason, claim_id)
+					 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+					 ON CONFLICT (id) DO UPDATE SET platform = excluded.platform, profile = excluded.profile, units = excluded.units,
+					   heartbeat_at = excluded.heartbeat_at, label = excluded.label, pid = excluded.pid, reason = excluded.reason, claim_id = excluded.claim_id`).run(entry.id, entry.platform, entry.profile, entry.units, entry.priority, entry.enqueuedAt, entry.heartbeatAt, ownerKey(entry.owner), JSON.stringify(entry.owner), entry.label ?? null, entry.pid ?? null, entry.reason ?? null, entry.claimId ?? null);
+      const row = this.db.query("SELECT * FROM boot_queue WHERE id = ?").get(entry.id);
+      if (!row)
+        throw new Error(`boot_queue row ${entry.id} vanished`);
+      return toQueueEntry(row);
+    });
+  }
+  refreshQueue(id, now, reason) {
+    return this.db.query("UPDATE boot_queue SET heartbeat_at = ?, reason = COALESCE(?, reason) WHERE id = ?").run(now, reason ?? null, id).changes > 0;
+  }
+  getClaimKey(ownerKey, key) {
+    const row = this.db.query("SELECT * FROM claim_keys WHERE owner_key = ? AND key = ?").get(ownerKey, key);
+    if (!row)
+      return;
+    return {
+      ownerKey: row.owner_key,
+      key: row.key,
+      claimId: row.claim_id,
+      platform: row.platform,
+      profile: row.profile,
+      count: row.count,
+      ready: row.ready === 1
+    };
+  }
+  setClaimKey(entry, now) {
+    this.db.query("INSERT OR REPLACE INTO claim_keys (owner_key, key, claim_id, platform, profile, count, ready, created_at) VALUES (?, ?, ?, ?, ?, ?, 0, ?)").run(entry.ownerKey, entry.key, entry.claimId, entry.platform, entry.profile, entry.count, now);
+  }
+  markClaimKeyReady(claimId) {
+    this.db.query("UPDATE claim_keys SET ready = 1 WHERE claim_id = ?").run(claimId);
+  }
+  deleteClaimKey(ownerKey, key) {
+    this.db.query("DELETE FROM claim_keys WHERE owner_key = ? AND key = ?").run(ownerKey, key);
+  }
+  deleteClaimKeysOf(claimId) {
+    this.db.query("DELETE FROM claim_keys WHERE claim_id = ?").run(claimId);
+  }
+  dequeue(id) {
+    return this.db.query("DELETE FROM boot_queue WHERE id = ?").run(id).changes > 0;
+  }
+  listQueue() {
+    return this.db.query("SELECT * FROM boot_queue ORDER BY enqueued_at, id").all().map(toQueueEntry);
+  }
+  reclaimStaleQueue(now, pidAlive) {
+    return this.transaction(() => {
+      const stale = this.listQueue().filter((e) => now - e.heartbeatAt > QUEUE_TTL_MS || e.pid !== undefined && !pidAlive(e.pid)).map((e) => e.id);
+      const stmt = this.db.query("DELETE FROM boot_queue WHERE id = ?");
+      for (const id of stale)
+        stmt.run(id);
+      return stale;
+    });
+  }
+  recordDevice(device, now) {
+    this.db.query(`INSERT INTO devices (platform, id, name, profile, runtime, created_at, last_used_at) VALUES (?, ?, ?, ?, ?, ?, ?)
+				 ON CONFLICT (platform, id) DO UPDATE SET name = excluded.name, profile = excluded.profile, runtime = excluded.runtime, last_used_at = excluded.last_used_at`).run(device.platform, device.id, device.name, device.profile ?? null, device.runtime ?? null, now, now);
+  }
+  listDevices(platform) {
+    const rows = platform === undefined ? this.db.query("SELECT * FROM devices ORDER BY platform, name").all() : this.db.query("SELECT * FROM devices WHERE platform = ? ORDER BY name").all(platform);
+    return rows.map(toDevice);
+  }
+  touchDevice(platform, id, now) {
+    this.db.query("UPDATE devices SET last_used_at = ? WHERE platform = ? AND id = ?").run(now, platform, id);
+  }
+  quarantineDevice(device, reason, now) {
+    this.transaction(() => {
+      this.db.query(`INSERT INTO devices (platform, id, name, profile, runtime, created_at, last_used_at, quarantined_at, quarantine_reason)
+					 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+					 ON CONFLICT (platform, id) DO UPDATE SET quarantined_at = excluded.quarantined_at, quarantine_reason = excluded.quarantine_reason`).run(device.platform, device.id, device.name, device.profile ?? null, device.runtime ?? null, now, now, now, reason ?? null);
+      this.recordEvent({
+        at: now,
+        type: "quarantined",
+        data: {
+          platform: device.platform,
+          deviceId: device.id,
+          deviceName: device.name,
+          ...reason !== undefined ? { reason } : {}
+        },
+        resourceKey: `device:${device.platform}:${device.id}`
+      });
+    });
+  }
+  unquarantineDevice(id, now) {
+    return this.transaction(() => {
+      const cleared = this.db.query("SELECT platform FROM devices WHERE id = ? AND quarantined_at IS NOT NULL").all(id);
+      this.db.query("UPDATE devices SET quarantined_at = NULL, quarantine_reason = NULL WHERE id = ? AND quarantined_at IS NOT NULL").run(id);
+      for (const { platform } of cleared) {
+        this.recordEvent({
+          at: now,
+          type: "unquarantined",
+          data: { platform, deviceId: id },
+          resourceKey: `device:${platform}:${id}`
+        });
+      }
+      return cleared.length;
+    });
+  }
+  setSlimmed(platform, id, at) {
+    this.db.query("UPDATE devices SET slimmed_at = ? WHERE platform = ? AND id = ?").run(at ?? null, platform, id);
+  }
+  markPersistent(platform, id, now) {
+    this.db.query("UPDATE devices SET persistent_at = ? WHERE platform = ? AND id = ?").run(now, platform, id);
+  }
+  forgetDevice(platform, id) {
+    this.db.query("DELETE FROM devices WHERE platform = ? AND id = ?").run(platform, id);
+  }
+  gcWork(now, idleMs, pidAlive) {
+    const staleLeases = this.listLeases().filter((l) => !isLeaseAlive(l, now, pidAlive)).length;
+    const lastGc = Number(this.getMeta("last_gc_at") ?? 0);
+    const row = this.db.query(`SELECT COUNT(*) AS n FROM devices d
+				 WHERE d.last_used_at <= ?1 - ?2 AND d.last_used_at + ?2 > ?3
+				   AND NOT EXISTS (SELECT 1 FROM leases l WHERE l.resource_key = 'device:' || d.platform || ':' || d.id)`).get(now, idleMs, lastGc);
+    return { staleLeases, idleDevices: row?.n ?? 0 };
+  }
+}
+function migrate(db) {
+  const row = db.query("PRAGMA user_version").get();
+  const current = row?.user_version ?? 0;
+  if (current >= MIGRATIONS.length)
+    return;
+  db.transaction(() => {
+    const again = db.query("PRAGMA user_version").get()?.user_version ?? 0;
+    for (let v = again;v < MIGRATIONS.length; v++) {
+      const sql = MIGRATIONS[v];
+      if (sql !== undefined)
+        db.exec(sql);
+    }
+    db.exec(`PRAGMA user_version = ${MIGRATIONS.length}`);
+  }).immediate();
+}
+function openStore(path = defaultDbPath()) {
+  mkdirSync4(dirname3(path), { recursive: true });
+  const db = new Database(path, { create: true, strict: true });
+  db.exec("PRAGMA busy_timeout = 15000");
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA synchronous = NORMAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  migrate(db);
+  return new Store(db);
+}
+
+// ../../packages/e2e/src/runner/callsite.ts
+import { join as join5 } from "path";
+var OWN_FILES = new Set(["callsite.ts", "scope.ts", "test.ts", "attempt.ts"].map((name) => join5(import.meta.dir, name)).concat(join5(import.meta.dir, "..", "index.ts")));
+var FRAME = /(?:\(|\s)((?:file:\/\/)?\/[^\s()]+?):\d+(?::\d+)?\)?\s*$/;
+function callerFile(stack = new Error().stack, extraOwn = () => false) {
+  for (const line of (stack ?? "").split(`
+`)) {
+    const raw = FRAME.exec(line)?.[1];
+    if (raw === undefined)
+      continue;
+    const path = raw.startsWith("file://") ? raw.slice("file://".length) : raw;
+    if (OWN_FILES.has(path) || extraOwn(path) || path.includes("/node_modules/"))
+      continue;
+    return path;
+  }
+  return "unknown";
+}
+
+// ../../packages/e2e/src/conditions/condition-events.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname4 } from "path";
+function openConditionSink(path) {
+  let ready = false;
+  return (event) => {
+    if (!ready) {
+      mkdirSync5(dirname4(path), { recursive: true });
+      ready = true;
+    }
+    appendFileSync2(path, `${JSON.stringify(event)}
+`);
+  };
+}
+var KNOWN_AREAS = new Set([
+  "network",
+  "location",
+  "clock",
+  "faults",
+  "permission",
+  "locale",
+  "a11y",
+  "battery",
+  "camera"
+]);
+
+// ../../packages/e2e/src/conditions/geo.ts
+var EARTH_RADIUS_M = 6371008.8;
+var rad = (deg) => deg * Math.PI / 180;
+var deg = (r) => r * 180 / Math.PI;
+function haversineM(a, b) {
+  const dLat = rad(b.lat - a.lat);
+  const dLon = rad(b.lon - a.lon);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(rad(a.lat)) * Math.cos(rad(b.lat)) * Math.sin(dLon / 2) ** 2;
+  return 2 * EARTH_RADIUS_M * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+function interpolate(a, b, f) {
+  if (f <= 0)
+    return a;
+  if (f >= 1)
+    return b;
+  const delta = haversineM(a, b) / EARTH_RADIUS_M;
+  if (delta < 0.000000000001)
+    return a;
+  const sinDelta = Math.sin(delta);
+  const wa = Math.sin((1 - f) * delta) / sinDelta;
+  const wb = Math.sin(f * delta) / sinDelta;
+  const lat1 = rad(a.lat);
+  const lon1 = rad(a.lon);
+  const lat2 = rad(b.lat);
+  const lon2 = rad(b.lon);
+  const x = wa * Math.cos(lat1) * Math.cos(lon1) + wb * Math.cos(lat2) * Math.cos(lon2);
+  const y = wa * Math.cos(lat1) * Math.sin(lon1) + wb * Math.cos(lat2) * Math.sin(lon2);
+  const z = wa * Math.sin(lat1) + wb * Math.sin(lat2);
+  return { lat: deg(Math.atan2(z, Math.hypot(x, y))), lon: deg(Math.atan2(y, x)) };
+}
+function routeSteps(points, speedMps, intervalS) {
+  const first = points[0];
+  if (!first)
+    return [];
+  if (points.length === 1)
+    return [first];
+  const stride = Math.max(speedMps * intervalS, 0.01);
+  const steps = [first];
+  let carried = 0;
+  for (let i = 1;i < points.length; i++) {
+    const from = points[i - 1];
+    const to = points[i];
+    const leg = haversineM(from, to);
+    let at = stride - carried;
+    while (at < leg - 0.000001) {
+      steps.push(interpolate(from, to, at / leg));
+      at += stride;
+    }
+    carried = leg - (at - stride);
+  }
+  const last = points[points.length - 1];
+  if (haversineM(steps[steps.length - 1], last) > 0.001)
+    steps.push(last);
+  else
+    steps[steps.length - 1] = last;
+  return steps;
+}
+function formatCoord(n) {
+  const fixed = n.toFixed(7);
+  return fixed.includes(".") ? fixed.replace(/\.?0+$/, "") : fixed;
+}
+
+// ../../packages/e2e/src/conditions/route-ticker.ts
+var DEFAULT_SPEED_MPS = 20;
+var DEFAULT_INTERVAL_S = 1;
+var MAX_CONSECUTIVE_FAILURES = 3;
+var realTickerClock = {
+  now: () => Date.now(),
+  sleep: (ms, signal) => new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done);
+  })
+};
+function startRouteTicker(route, deps) {
+  const controller = new AbortController;
+  const { signal } = controller;
+  const startedAt = deps.now();
+  const intervalMs = (route.intervalS ?? DEFAULT_INTERVAL_S) * 1000;
+  const steps = routeSteps(route.points, route.speedMps ?? DEFAULT_SPEED_MPS, route.intervalS ?? DEFAULT_INTERVAL_S);
+  function* playlist() {
+    do
+      yield* steps;
+    while (route.loop && steps.length > 0);
+  }
+  const total = steps.length;
+  const pace = async (done) => {
+    if (!route.loop && done >= total)
+      return false;
+    await deps.sleep(Math.max(0, startedAt + done * intervalMs - deps.now()), signal);
+    return true;
+  };
+  const run = async () => {
+    const count = { ticks: 0, failures: 0, index: 0 };
+    let lastError = "";
+    const sendOne = async (step) => {
+      const failure = await deps.fix(step).catch((e) => e instanceof Error ? e.message : String(e));
+      if (!failure) {
+        count.failures = 0;
+        count.ticks++;
+        return true;
+      }
+      lastError = failure;
+      count.failures++;
+      return count.failures < MAX_CONSECUTIVE_FAILURES;
+    };
+    for (const step of playlist()) {
+      if (signal.aborted)
+        return { ticks: count.ticks, stopped: "aborted" };
+      if (!await sendOne(step))
+        return { ticks: count.ticks, stopped: "failed", error: lastError };
+      count.index++;
+      if (!await pace(count.index))
+        break;
+    }
+    return { ticks: count.ticks, stopped: signal.aborted ? "aborted" : "finished" };
+  };
+  return { stop: () => controller.abort(), done: run() };
+}
+
+// ../../packages/e2e/src/conditions/scheduler.ts
+var MAX_CONSECUTIVE_FAILURES2 = 3;
+var ONLINE = { kind: "online" };
+var OFFLINE = { kind: "offline" };
+function seededRng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var messageOf = (e) => e instanceof Error ? e.message : String(e);
+async function attempt(run, what) {
+  if (!run)
+    return `target cannot apply ${what}`;
+  try {
+    const res = await run();
+    return res.success ? undefined : res.error.message;
+  } catch (e) {
+    return messageOf(e);
+  }
+}
+function core() {
+  const controller = new AbortController;
+  return { controller, signal: controller.signal, status: { state: "running", transitions: 0 }, transitions: 0 };
+}
+function invalid(message) {
+  return {
+    stop: () => {
+      return;
+    },
+    done: Promise.resolve({ transitions: 0, stopped: "failed", error: message }),
+    current: () => ({ state: "failed", transitions: 0, error: message })
+  };
+}
+function conclude(state, end, error) {
+  const { transitions } = state;
+  if (error !== undefined) {
+    state.status = { state: "failed", transitions, error };
+    return { transitions, stopped: "failed", error };
+  }
+  state.status = { state: end === "finished" ? "finished" : "stopped", transitions };
+  return { transitions, stopped: end };
+}
+function applier(target, deps, state) {
+  const net = target.network?.bind(target);
+  const loc = target.location?.bind(target);
+  const tally = { failures: 0, lastError: "" };
+  const record = async (run, what) => {
+    const failure = await attempt(run, what);
+    if (failure) {
+      tally.failures++;
+      tally.lastError = failure;
+      return false;
+    }
+    tally.failures = 0;
+    state.transitions++;
+    return true;
+  };
+  return {
+    tally,
+    async network(condition) {
+      const landed = await record(net && (() => net(condition)), "network");
+      if (landed)
+        deps.sink?.({ type: "condition", area: "network", value: condition, at: deps.now() });
+      return landed;
+    },
+    async location(op) {
+      const landed = await record(loc && (() => loc(op)), "location");
+      if (landed)
+        deps.sink?.({ type: "condition", area: "location", value: op, at: deps.now() });
+      return landed;
+    }
+  };
+}
+function startFlap(target, options, deps) {
+  if (!(options.upMs > 0 && options.downMs > 0 && Number.isFinite(options.upMs + options.downMs))) {
+    return invalid("flap needs upMs and downMs above 0");
+  }
+  if (options.base?.kind === "flap")
+    return invalid("flap base cannot itself be a flap");
+  const base = options.base ?? ONLINE;
+  const rng = deps.rng ?? seededRng(options.seed ?? 1);
+  const jitter = (options.jitterPct ?? 0) / 100;
+  const state = core();
+  const { signal } = state;
+  const apply = applier(target, deps, state);
+  const stretch = (ms) => Math.max(1, ms * (1 + (rng() * 2 - 1) * jitter));
+  const runPhase = async (phase, skipApply, deadline) => {
+    const landed = skipApply || await apply.network(phase === "up" ? base : OFFLINE);
+    state.status = { state: "running", transitions: state.transitions, phase };
+    const next = deadline + stretch(phase === "up" ? options.upMs : options.downMs);
+    await deps.sleep(Math.max(0, next - deps.now()), signal);
+    return [landed && phase === "up", next];
+  };
+  const run = async () => {
+    let phase = "up";
+    let atBase = false;
+    let deadline = deps.now();
+    let skipApply = options.applyInitial === false;
+    while (!signal.aborted && apply.tally.failures < MAX_CONSECUTIVE_FAILURES2) {
+      [atBase, deadline] = await runPhase(phase, skipApply, deadline);
+      skipApply = false;
+      phase = phase === "up" ? "down" : "up";
+    }
+    const { failures, lastError } = apply.tally;
+    if (!atBase)
+      await apply.network(base);
+    return conclude(state, "aborted", failures >= MAX_CONSECUTIVE_FAILURES2 ? lastError : undefined);
+  };
+  return { stop: () => state.controller.abort(), done: run(), current: () => state.status };
+}
+function startTimeline(target, steps, deps) {
+  if (steps.some((s) => !(s.atMs >= 0) || !Number.isFinite(s.atMs)))
+    return invalid("timeline atMs must be 0 or more");
+  const ordered = [...steps].sort((a, b) => a.atMs - b.atMs);
+  const startedAt = deps.now();
+  const state = core();
+  const { signal } = state;
+  const apply = applier(target, deps, state);
+  const runStep = async (step) => {
+    const errors = [];
+    if (step.network && !await apply.network(step.network))
+      errors.push(apply.tally.lastError);
+    if (step.location && !await apply.location(step.location))
+      errors.push(apply.tally.lastError);
+    return errors.length > 0 ? errors.join("; ") : undefined;
+  };
+  const run = async () => {
+    let stepFailures = 0;
+    let lastError = "";
+    for (const [index, step] of ordered.entries()) {
+      await deps.sleep(Math.max(0, startedAt + step.atMs - deps.now()), signal);
+      if (signal.aborted)
+        break;
+      state.status = { state: "running", transitions: state.transitions, step: index };
+      const problem = await runStep(step);
+      stepFailures = problem === undefined ? 0 : stepFailures + 1;
+      lastError = problem ?? lastError;
+      if (stepFailures >= MAX_CONSECUTIVE_FAILURES2)
+        return conclude(state, "aborted", lastError);
+    }
+    return conclude(state, signal.aborted ? "aborted" : "finished");
+  };
+  return { stop: () => state.controller.abort(), done: run(), current: () => state.status };
+}
+
+// ../../packages/e2e/src/conditions/device-conditions.ts
+var ONLINE2 = { kind: "online" };
+var REAL_CLOCK = { kind: "real" };
+function a11yOpOf(config) {
+  const { fontScale: _scale, ...op } = config;
+  return op;
+}
+var stderrLog = (line) => {
+  process.stderr.write(`${line}
+`);
+};
+function invalid2(message) {
+  return new E2eError2("INVALID_ARGUMENT", message);
+}
+function durationMs(value, what) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0)
+      throw invalid2(`${what} must be 0 or more, got ${String(value)}`);
+    return value;
+  }
+  const parsed = parseDuration(value);
+  if (!parsed.success)
+    throw invalid2(`${what}: ${parsed.error}`);
+  return parsed.data;
+}
+function network(input) {
+  const condition = toNetworkCondition(input);
+  if (!condition.success)
+    throw invalid2(condition.error);
+  return condition.data;
+}
+function instant(at) {
+  const date = at instanceof Date ? new Date(at.getTime()) : new Date(at);
+  if (Number.isNaN(date.getTime()))
+    throw invalid2(`invalid time ${JSON.stringify(at)} (use an ISO 8601 string, a Date or epoch ms)`);
+  return date;
+}
+function validatePoint(point) {
+  const ok = Number.isFinite(point.lat) && Number.isFinite(point.lon) && Math.abs(point.lat) <= 90 && Math.abs(point.lon) <= 180;
+  if (!ok)
+    throw invalid2(`invalid location ${point.lat},${point.lon} (lat within 90, lon within 180)`);
+}
+var SCENARIOS = ["city-run", "city-bike", "freeway"];
+function locationOf(input) {
+  if ("kind" in input)
+    return input;
+  validatePoint(input);
+  return { kind: "point", lat: input.lat, lon: input.lon };
+}
+var PACKAGE_SRC = `${resolve3(import.meta.dir, "..")}/`;
+function callingSpecDir() {
+  const file = callerFile(new Error().stack, (path) => path.startsWith(PACKAGE_SRC) && !path.endsWith(".test.ts"));
+  return file === "unknown" ? undefined : dirname5(file);
+}
+var FACINGS = {
+  back: ["back"],
+  front: ["front"],
+  both: ["back", "front"]
+};
+function facingsOf(choice) {
+  const facings = FACINGS[choice ?? "back"];
+  if (facings === undefined)
+    throw invalid2(`unknown camera facing "${String(choice)}" (use back, front or both)`);
+  return facings;
+}
+var registry2 = new WeakMap;
+function registerConditions(device, internals) {
+  registry2.set(device, internals);
+}
+function conditionsOf(device) {
+  return registry2.get(device);
+}
+function conditionSinkFor(session) {
+  return session.results === undefined ? undefined : openConditionSink(session.results.path);
+}
+function createDeviceConditions(deps) {
+  const { driver, env } = deps;
+  const ticker = deps.tickerClock ?? realTickerClock;
+  const log = deps.log ?? stderrLog;
+  const normalized = normalizeConditions(env.conditions ?? {});
+  if (!normalized.success)
+    throw new E2eError2("SESSION", `invalid conditions: ${normalized.error}`);
+  const baseline = normalized.data.conditions;
+  let currentNetwork = ONLINE2;
+  let currentFaults = [];
+  let currentClock = REAL_CLOCK;
+  let clockSetAt = ticker.now();
+  let networkDirty = false;
+  let locationDirty = false;
+  let clockDirty = false;
+  let permissionsDirty = false;
+  let localeDirty = false;
+  let a11yDirty = false;
+  let batteryDirty = false;
+  let cameraDirty = false;
+  let currentCamera = {};
+  const permissionStates = new Map;
+  let permissionBundle;
+  let currentLocale = {};
+  let currentA11y = {};
+  let flap;
+  const runs = new Set;
+  const recorder = deps.recorder;
+  const emit = (event) => {
+    deps.sink?.({ ...event, type: "condition", at: ticker.now() });
+  };
+  async function call(what, run) {
+    const result = await settled(run, what, deps.signal());
+    if (result.success)
+      return result.data;
+    const error = toE2eError(result.error, what);
+    if (result.error.code === "E_NETWORK_RELAUNCH") {
+      throw new E2eError2(error.code, `${error.message}
+the app runs without the warden network dylib: declare \`conditions.network\` for the suite so it launches with it, or pass { relaunch: true }`);
+    }
+    throw error;
+  }
+  const target = (options) => ({
+    network: async (condition) => {
+      const result = await driver.network(condition, options?.relaunch === undefined ? undefined : { relaunch: options.relaunch });
+      if (result.success)
+        recorder?.record("network", condition);
+      return result;
+    },
+    location: async (op) => {
+      const result = await driver.location(op);
+      if (result.success)
+        recorder?.record("location", op);
+      return result;
+    }
+  });
+  function track(scheduler) {
+    const run = {
+      async stop() {
+        scheduler.stop();
+        const outcome = await scheduler.done;
+        runs.delete(run);
+        if (flap?.run === run)
+          flap = undefined;
+        return outcome;
+      },
+      done: scheduler.done,
+      status: () => scheduler.current()
+    };
+    runs.add(run);
+    return run;
+  }
+  async function stopFlap() {
+    const running = flap;
+    if (running === undefined)
+      return;
+    await running.run.stop();
+  }
+  async function applyNetwork(condition, options) {
+    await stopFlap();
+    networkDirty = true;
+    const opts = options?.relaunch === undefined ? undefined : { relaunch: options.relaunch };
+    const state = await call("network", () => driver.network(condition, opts));
+    currentNetwork = condition;
+    recorder?.record("network", condition);
+    emit({ area: "network", value: condition });
+    return state;
+  }
+  async function startFlapRun(options, netOptions) {
+    const upMs = durationMs(options.up, "flap up");
+    const downMs = durationMs(options.down, "flap down");
+    if (!(upMs > 0 && downMs > 0))
+      throw invalid2("flap needs up and down above 0");
+    const base = options.base === undefined ? ONLINE2 : network(options.base);
+    if (base.kind === "flap")
+      throw invalid2("flap base cannot itself be a flap");
+    await applyNetwork(base, netOptions);
+    const scheduler = startFlap(target(netOptions), {
+      upMs,
+      downMs,
+      base,
+      applyInitial: false,
+      ...options.jitterPct === undefined ? {} : { jitterPct: options.jitterPct },
+      ...options.seed === undefined ? {} : { seed: options.seed }
+    }, { ...ticker, ...deps.sink === undefined ? {} : { sink: deps.sink } });
+    const run = track(scheduler);
+    flap = { run, options };
+    currentNetwork = {
+      kind: "flap",
+      upMs,
+      downMs,
+      base,
+      ...options.jitterPct === undefined ? {} : { jitterPct: options.jitterPct }
+    };
+    emit({ area: "network", value: currentNetwork });
+    return run;
+  }
+  async function setNetwork(input, options) {
+    const condition = network(input);
+    if (condition.kind === "flap") {
+      await startFlapRun({
+        up: condition.upMs,
+        down: condition.downMs,
+        ...condition.jitterPct === undefined ? {} : { jitterPct: condition.jitterPct },
+        ...condition.base === undefined ? {} : { base: condition.base }
+      }, options);
+      return { online: true, condition, needsProxy: [] };
+    }
+    return applyNetwork(condition, options);
+  }
+  async function restoreNetwork(previous, previousFlap, options) {
+    if (previous.kind === "flap" && previousFlap !== undefined)
+      await startFlapRun(previousFlap, options);
+    else
+      await applyNetwork(previous, options);
+  }
+  async function resetNetwork() {
+    await stopFlap();
+    if (currentFaults.length > 0)
+      await setFaults([]);
+    const goal = baseline.network ?? ONLINE2;
+    await applyNetwork(goal);
+    networkDirty = false;
+    recorder?.settle("network", goal, goal.kind === "online");
+  }
+  async function setFaults(rules) {
+    networkDirty = true;
+    const result = await call("network faults", () => driver.networkFaults(rules));
+    currentFaults = rules;
+    recorder?.record("network", currentNetwork);
+    emit({ area: "faults", value: { kind: "faults", rules } });
+    return result;
+  }
+  const networkApi = {
+    set: setNetwork,
+    async during(condition, fn, options) {
+      const previous = currentNetwork;
+      const previousFlap = flap?.options;
+      await setNetwork(condition, options);
+      let result;
+      try {
+        result = await fn();
+      } catch (error) {
+        await restoreNetwork(previous, previousFlap, options).catch((restoreError) => log(`[warden-e2e] network.during: restoring the previous network failed: ${String(restoreError instanceof Error ? restoreError.message : restoreError)}`));
+        throw error;
+      }
+      await restoreNetwork(previous, previousFlap, options);
+      return result;
+    },
+    flap: (options) => startFlapRun(options),
+    fault: (rules) => setFaults("match" in rules ? [rules] : rules),
+    async status() {
+      return { condition: currentNetwork, faults: currentFaults, flapping: flap !== undefined };
+    },
+    reset: resetNetwork
+  };
+  async function applyLocation(op) {
+    locationDirty = true;
+    await call("location", () => driver.location(op));
+    recorder?.record("location", op);
+    emit({ area: "location", value: op });
+  }
+  const locationApi = {
+    async set(point) {
+      validatePoint(point);
+      await applyLocation({
+        kind: "point",
+        lat: point.lat,
+        lon: point.lon,
+        ...point.altM === undefined ? {} : { altM: point.altM }
+      });
+    },
+    async route(points, options = {}) {
+      const pace = {
+        ...options.speedMps === undefined ? {} : { speedMps: options.speedMps }
+      };
+      if ("gpx" in points) {
+        await applyLocation({ kind: "gpx", path: resolve3(points.gpx), ...pace });
+        return;
+      }
+      if (points.length === 0)
+        throw invalid2("a route needs at least one point");
+      for (const point of points)
+        validatePoint(point);
+      await applyLocation({
+        kind: "route",
+        points,
+        ...pace,
+        ...options.intervalS === undefined ? {} : { intervalS: options.intervalS },
+        ...options.loop === undefined ? {} : { loop: options.loop }
+      });
+    },
+    async scenario(name) {
+      if (!SCENARIOS.includes(name))
+        throw invalid2(`unknown scenario "${String(name)}" (use ${SCENARIOS.join(", ")})`);
+      await applyLocation({ kind: "scenario", name });
+    },
+    clear: () => applyLocation({ kind: "clear" })
+  };
+  async function applyClock(condition) {
+    const op = driver.clock;
+    clockDirty = true;
+    if (typeof op !== "function") {
+      throw toE2eError({ code: "E_UNSUPPORTED", message: "this driver has no clock condition", retryable: false }, "clock");
+    }
+    await call("clock", () => op.call(driver, condition));
+    currentClock = condition;
+    clockSetAt = ticker.now();
+    emit({ area: "clock", value: condition });
+  }
+  function clockFor(at, frozen) {
+    const iso = instant(at).toISOString();
+    return frozen === true ? { kind: "frozen", at: iso } : { kind: "fixed", at: iso };
+  }
+  function advanced(by) {
+    switch (currentClock.kind) {
+      case "real":
+        return { kind: "offset", ms: by };
+      case "offset":
+        return { kind: "offset", ms: currentClock.ms + by };
+      case "frozen":
+        return { kind: "frozen", at: new Date(Date.parse(currentClock.at) + by).toISOString() };
+      case "fixed": {
+        const now = Date.parse(currentClock.at) + (ticker.now() - clockSetAt);
+        return { kind: "fixed", at: new Date(now + by).toISOString() };
+      }
+    }
+  }
+  const clockApi = {
+    async set(at, options) {
+      await applyClock(clockFor(at, options?.frozen));
+    },
+    async advance(by) {
+      await applyClock(advanced(durationMs(by, "advance")));
+    },
+    async during(at, fn, options) {
+      const previous = currentClock;
+      await applyClock(clockFor(at, options?.frozen));
+      let result;
+      try {
+        result = await fn();
+      } catch (error) {
+        await applyClock(previous).catch((restoreError) => log(`[warden-e2e] clock.during: restoring the previous clock failed: ${String(restoreError instanceof Error ? restoreError.message : restoreError)}`));
+        throw error;
+      }
+      await applyClock(previous);
+      return result;
+    },
+    async reset() {
+      await applyClock(baseline.clock ?? REAL_CLOCK);
+      clockDirty = false;
+    },
+    status: () => currentClock
+  };
+  function settingOp(name) {
+    const op = driver[name];
+    if (typeof op !== "function") {
+      throw toE2eError({ code: "E_UNSUPPORTED", message: `this driver has no ${name} op`, retryable: false }, name);
+    }
+    return op.bind(driver);
+  }
+  const recordPermissions = (bundleId) => {
+    const value = {
+      grants: [...permissionStates].map(([permission, state]) => ({ bundleId, permission, state }))
+    };
+    recorder?.record("permission", value);
+    emit({ area: "permission", value });
+  };
+  async function applyPermissions(grants, options) {
+    permissionsDirty = true;
+    const op = settingOp("permissions");
+    const state = await call("permissions", () => op(grants, options ?? { bundleId: env.bundleId }));
+    for (const { permission, state: applied } of state.applied)
+      permissionStates.set(permission, applied);
+    permissionBundle = state.bundleId;
+    recordPermissions(state.bundleId);
+    return state;
+  }
+  const permissionsApi = {
+    set: applyPermissions,
+    async reset(options) {
+      const baselinePermissions = baseline.permissions ?? {};
+      const back = {};
+      for (const name of permissionStates.keys())
+        back[name] = baselinePermissions[name] ?? "unset";
+      if (Object.keys(back).length === 0)
+        return;
+      await applyPermissions(back, options ?? (permissionBundle ? { bundleId: permissionBundle } : undefined));
+      permissionsDirty = false;
+      permissionStates.clear();
+      recorder?.settle("permission", { grants: [] }, true);
+    }
+  };
+  function recordLocale() {
+    const empty = currentLocale.locale === undefined && currentLocale.timezone === undefined;
+    if (empty)
+      recorder?.settle("locale", currentLocale, true);
+    else
+      recorder?.record("locale", currentLocale);
+    emit({ area: "locale", value: currentLocale });
+  }
+  async function applyTimezone(tz) {
+    localeDirty = true;
+    const op = settingOp("timezone");
+    const previous = currentLocale.previousTimezone;
+    const state = await call("timezone", () => op(tz, previous === undefined ? undefined : { previous }));
+    const { timezone: _gone, ...rest } = currentLocale;
+    currentLocale = {
+      ...rest,
+      ...tz === null ? {} : { timezone: tz },
+      ...previous ?? state.previous ? { previousTimezone: previous ?? state.previous } : {}
+    };
+    recordLocale();
+    return state;
+  }
+  async function applyLocale(tag, options) {
+    localeDirty = true;
+    const op = settingOp("locale");
+    const state = await call("locale", () => op(tag, options ?? { bundleId: env.bundleId }));
+    const { locale: _gone, ...rest } = currentLocale;
+    currentLocale = {
+      ...rest,
+      ...tag === null ? {} : { locale: tag },
+      ...state.bundleId === undefined ? {} : { bundleId: state.bundleId }
+    };
+    recordLocale();
+    return state;
+  }
+  function checkedA11y(op) {
+    if (op === null)
+      return;
+    if (op.textSize !== undefined) {
+      const size = resolveTextSize(op.textSize);
+      if (!size.success)
+        throw invalid2(size.error);
+    }
+    if (Object.keys(op).length === 0)
+      throw invalid2("a11y needs at least one of textSize, boldText, contrast, reduceMotion");
+  }
+  async function applyA11y(op) {
+    checkedA11y(op);
+    a11yDirty = true;
+    const run = settingOp("a11y");
+    const state = await call("a11y", () => run(op));
+    const resolved = op?.textSize === undefined ? undefined : resolveTextSize(op.textSize);
+    currentA11y = op === null ? {} : {
+      ...currentA11y,
+      ...appliedA11y(op, state.applied),
+      ...resolved?.success ? { fontScale: resolved.data.scale } : {}
+    };
+    if (op?.screenReader === false && currentA11y.screenReaderPrevious !== undefined) {
+      const { screenReader: _off, screenReaderPrevious: _prior, ...rest } = currentA11y;
+      currentA11y = rest;
+    } else if (state.screenReaderPrevious !== undefined) {
+      currentA11y = { ...currentA11y, screenReaderPrevious: state.screenReaderPrevious };
+    }
+    if (Object.keys(currentA11y).length === 0)
+      recorder?.settle("a11y", currentA11y, true);
+    else
+      recorder?.record("a11y", currentA11y);
+    emit({ area: "a11y", value: currentA11y });
+    return state;
+  }
+  async function applyBattery(op) {
+    batteryDirty = true;
+    const run = settingOp("battery");
+    const state = await call("battery", () => run(op));
+    const value = op === null ? {} : { ...op, cosmetic: state.cosmetic };
+    if (op === null)
+      recorder?.settle("battery", value, true);
+    else
+      recorder?.record("battery", value);
+    emit({ area: "battery", value });
+    return state;
+  }
+  const home = deps.wardenHome ?? wardenHome(process.env);
+  async function applyCamera(next) {
+    cameraDirty = true;
+    const run = settingOp("camera");
+    const empty = Object.keys(next).length === 0;
+    const state = await call("camera", () => run(empty ? null : next));
+    currentCamera = state.feeds;
+    if (Object.keys(currentCamera).length === 0)
+      recorder?.settle("camera", currentCamera, true);
+    else
+      recorder?.record("camera", currentCamera);
+    emit({ area: "camera", value: currentCamera });
+    return state;
+  }
+  function stage(facing, source, loop) {
+    const staged = stageCameraFeed({ wardenHome: home, udid: env.udid, facing, source, loop });
+    if (!staged.success) {
+      throw invalid2(`camera failed: ${staged.error.code}: ${staged.error.message}`);
+    }
+    return staged.data;
+  }
+  function specPath(path, dir) {
+    if (typeof path !== "string" || path === "")
+      throw invalid2("camera.set needs the path of an image or video");
+    return resolve3(dir ?? (env.specsDir !== undefined ? resolve3(env.specsDir) : process.cwd()), path);
+  }
+  const cameraApi = {
+    async set(path, options = {}) {
+      const dir = (deps.specDir ?? callingSpecDir)();
+      const source = specPath(path, dir);
+      const facings = facingsOf(options.facing);
+      const loop = options.loop ?? true;
+      const next = { ...currentCamera };
+      for (const facing of facings) {
+        const feed = stage(facing, source, loop);
+        if (feed !== undefined)
+          next[facing] = feed;
+      }
+      return applyCamera(next);
+    },
+    async clear(facing = "both") {
+      const next = { ...currentCamera };
+      for (const f of facingsOf(facing))
+        delete next[f];
+      return applyCamera(next);
+    },
+    async status() {
+      return { feeds: currentCamera };
+    }
+  };
+  function baselineCamera() {
+    const feeds = {};
+    for (const facing of ["back", "front"]) {
+      const configured = env.cameraFeeds?.[facing];
+      if (configured === undefined)
+        continue;
+      const feed = stage(facing, configured.path, configured.loop);
+      if (feed !== undefined)
+        feeds[facing] = feed;
+    }
+    return feeds;
+  }
+  async function startTimelineRun(steps) {
+    const converted = steps.map((step, index) => {
+      const atMs = durationMs(step.at, `timeline step ${index} at`);
+      const converted = { atMs };
+      if (step.network !== undefined) {
+        const condition = network(step.network);
+        if (condition.kind === "flap")
+          throw invalid2(`timeline step ${index}: use device.network.flap for a flap`);
+        converted.network = condition;
+      }
+      if (step.location !== undefined)
+        converted.location = locationOf(step.location);
+      return converted;
+    });
+    networkDirty = true;
+    locationDirty = true;
+    const scheduler = startTimeline(target(), converted, {
+      ...ticker,
+      ...deps.sink === undefined ? {} : { sink: deps.sink }
+    });
+    const status = scheduler.current();
+    if (status.state === "failed")
+      throw invalid2(status.error);
+    const run = track(scheduler);
+    const last = converted.at(-1);
+    if (last?.network !== undefined)
+      currentNetwork = last.network;
+    return run;
+  }
+  async function stopRuns() {
+    const failures = [];
+    for (const run of [...runs]) {
+      const outcome = await run.stop();
+      if (outcome.stopped === "failed")
+        failures.push(outcome.error);
+    }
+    if (failures.length > 0) {
+      throw new E2eError2("ACTION_FAILED", `a network flap or timeline stopped on its own after failing: ${failures[0]}`);
+    }
+  }
+  const declared = baseline.network !== undefined || baseline.location !== undefined || baseline.clock !== undefined || baseline.permissions !== undefined || baseline.locale !== undefined || baseline.timezone !== undefined || baseline.a11y !== undefined || env.cameraFeeds !== undefined;
+  const internals = {
+    declared,
+    dirty: () => networkDirty || locationDirty || clockDirty || permissionsDirty || localeDirty || a11yDirty || batteryDirty || cameraDirty || runs.size > 0,
+    wantsInject: () => baseline.network !== undefined || baseline.clock !== undefined || currentNetwork.kind !== "online" || currentClock.kind !== "real",
+    async applyBaseline() {
+      if (baseline.permissions !== undefined) {
+        for (const [name, state] of Object.entries(baseline.permissions))
+          permissionStates.set(name, state);
+        await applyPermissions(baseline.permissions);
+      }
+      if (baseline.timezone !== undefined)
+        await applyTimezone(baseline.timezone);
+      if (baseline.locale !== undefined)
+        await applyLocale(baseline.locale);
+      if (baseline.a11y !== undefined)
+        await applyA11y(a11yOpOf(baseline.a11y));
+      if (baseline.clock !== undefined)
+        await applyClock(baseline.clock);
+      if (baseline.location !== undefined)
+        await applyLocation(baseline.location);
+      if (baseline.network !== undefined)
+        await applyNetwork(baseline.network, { relaunch: true });
+      if (env.cameraFeeds !== undefined)
+        await applyCamera(baselineCamera());
+      cameraDirty = false;
+      networkDirty = false;
+      locationDirty = false;
+      clockDirty = false;
+      permissionsDirty = false;
+      localeDirty = false;
+      a11yDirty = false;
+      batteryDirty = false;
+    },
+    async teardown() {
+      const errors = [];
+      const attempt = async (run) => {
+        try {
+          await run();
+        } catch (error) {
+          errors.push(error);
+        }
+      };
+      await attempt(stopRuns);
+      if (networkDirty)
+        await attempt(resetNetwork);
+      if (locationDirty) {
+        await attempt(async () => {
+          const goal = baseline.location ?? { kind: "clear" };
+          await applyLocation(goal);
+          locationDirty = false;
+          recorder?.settle("location", goal, goal.kind === "clear");
+        });
+      }
+      if (clockDirty)
+        await attempt(clockApi.reset);
+      if (permissionsDirty)
+        await attempt(() => permissionsApi.reset());
+      if (localeDirty) {
+        await attempt(async () => {
+          await applyTimezone(baseline.timezone ?? null);
+          await applyLocale(baseline.locale ?? null);
+          localeDirty = false;
+        });
+      }
+      if (a11yDirty) {
+        await attempt(async () => {
+          await applyA11y(null);
+          if (baseline.a11y !== undefined)
+            await applyA11y(a11yOpOf(baseline.a11y));
+          a11yDirty = false;
+        });
+      }
+      if (batteryDirty) {
+        await attempt(async () => {
+          await applyBattery(null);
+          batteryDirty = false;
+        });
+      }
+      if (cameraDirty) {
+        await attempt(async () => {
+          await applyCamera(baselineCamera());
+          cameraDirty = false;
+        });
+      }
+      if (errors.length > 0)
+        throw errors[0];
+    }
+  };
+  return {
+    network: networkApi,
+    location: locationApi,
+    clock: clockApi,
+    permissions: permissionsApi,
+    timezone: applyTimezone,
+    locale: applyLocale,
+    a11y: applyA11y,
+    battery: applyBattery,
+    camera: cameraApi,
+    memoryWarning: async (options) => {
+      const op = settingOp("memoryWarning");
+      await call("memoryWarning", () => op(options ?? { bundleId: env.bundleId }));
+    },
+    push: async (payload, options) => {
+      const op = settingOp("push");
+      await call("push", () => op(payload, options ?? { bundleId: env.bundleId }));
+    },
+    timeline: startTimelineRun,
+    internals
+  };
+}
+
+// ../../packages/e2e/src/perf/device-perf.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync6, writeFileSync } from "fs";
+import { join as join6 } from "path";
+
+// ../../packages/e2e/src/perf/budgets.ts
+var BUDGET_KEYS = ["startupColdMs", "jankPct", "maxCommitMs", "p95CpuPct", "peakMemoryMb"];
+function measured(report, metric) {
+  const m = report.metrics;
+  switch (metric) {
+    case "startupColdMs":
+      return m.startupColdMs;
+    case "jankPct":
+      return m.jankPct;
+    case "maxCommitMs":
+      return m.topCommitMs;
+    case "p95CpuPct":
+      return m.cpuP95Pct;
+    case "peakMemoryMb": {
+      const kb = Math.max(m.peakPssKb ?? 0, m.peakRssKb ?? 0);
+      return kb > 0 ? kb / 1024 : undefined;
+    }
+  }
+}
+function checkBudgets(report, base, overrides) {
+  const budgets = { ...base, ...overrides };
+  const breaches = [];
+  for (const metric of BUDGET_KEYS) {
+    const budget = budgets[metric];
+    if (budget === undefined)
+      continue;
+    const value = measured(report, metric);
+    if (value !== undefined && value > budget)
+      breaches.push({ metric, value, budget });
+  }
+  return breaches;
+}
+var round = (n) => Math.round(n * 10) / 10;
+function describeBreaches(breaches, reportPath) {
+  const lines = breaches.map((b) => `  ${b.metric}: ${round(b.value)} > budget ${b.budget}`);
+  return [
+    `perf_budget: ${breaches.length} metric${breaches.length === 1 ? "" : "s"} over budget`,
+    ...lines,
+    ...reportPath === undefined ? [] : [`  report: ${reportPath}`]
+  ].join(`
+`);
+}
+function parseBudgets(raw) {
+  if (raw === undefined || raw === "")
+    return {};
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (typeof json !== "object" || json === null)
+    return {};
+  const out = {};
+  for (const key of BUDGET_KEYS) {
+    const v = json[key];
+    if (typeof v === "number" && Number.isFinite(v) && v >= 0)
+      out[key] = v;
+  }
+  return out;
+}
+
+// ../../packages/e2e/src/perf/device-perf.ts
+var PERF_DIR = "perf";
+function parseEnvelope2(stdout) {
+  try {
+    const json = JSON.parse(stdout.trim().split(`
+`).at(-1) ?? "");
+    if (typeof json !== "object" || json === null || !("ok" in json))
+      return;
+    return json;
+  } catch {
+    return;
+  }
+}
+var flagsOf = (o) => [
+  ...o.js ? ["--js"] : [],
+  ...o.react ? ["--react"] : [],
+  ...typeof o.native === "string" ? [`--native=${o.native}`] : o.native ? ["--native"] : [],
+  ...o.metrics ? ["--metrics"] : [],
+  ...o.frames ? ["--frames"] : [],
+  ...o.logs ? ["--logs"] : [],
+  ...o.all ? ["--all"] : [],
+  ...o.relaunch ? ["--relaunch"] : [],
+  ...o.reset ? ["--reset"] : [],
+  ...o.maxDurationMs === undefined ? [] : ["--max-duration", `${Math.ceil(o.maxDurationMs / 1000)}s`]
+];
+var isRecord2 = (v) => typeof v === "object" && v !== null;
+function saveReport(deps, result, report, sessionId) {
+  const sessionReport = typeof result.reportPath === "string" ? result.reportPath : undefined;
+  const attempt = deps.attemptDir();
+  if (attempt === undefined)
+    return sessionReport;
+  const out = join6(attempt, PERF_DIR);
+  mkdirSync6(out, { recursive: true });
+  const sessionDir = typeof result.dir === "string" ? result.dir : undefined;
+  const write = (name, from, fallback) => {
+    if (from !== undefined && existsSync4(from))
+      copyFileSync2(from, join6(out, name));
+    else if (fallback !== undefined)
+      writeFileSync(join6(out, name), fallback);
+    else
+      return;
+    deps.addFile?.(`${PERF_DIR}/${name}`);
+  };
+  write("report.json", sessionReport, `${JSON.stringify(report, null, 2)}
+`);
+  write("report.md", sessionDir === undefined ? undefined : join6(sessionDir, "report.md"));
+  write("session.json", undefined, `${JSON.stringify({ sessionId, dir: sessionDir }, null, 2)}
+`);
+  return join6(out, "report.json");
+}
+function createDevicePerf(deps) {
+  const run = async (sub, extra) => {
+    if (deps.unavailable !== undefined)
+      throw new E2eError2("SESSION", `device.perf unavailable: ${deps.unavailable}`);
+    const { code, stdout, stderr } = await deps.exec(["perf", sub, "--json", "--udid", deps.udid, ...extra]);
     const env = parseEnvelope2(stdout);
     if (env === undefined || !env.ok) {
       const why = env === undefined ? stderr.trim() || `exit ${code}` : `${env.error.code}: ${env.error.message}`;
       throw new E2eError2("SESSION", `warden perf ${sub} failed: ${why}`);
     }
-    return isRecord(env.result) ? env.result : {};
+    return isRecord2(env.result) ? env.result : {};
   };
   let active = false;
   return {
@@ -5727,7 +8896,7 @@ function createDevicePerf(deps) {
       const result = await run("stop", []);
       active = false;
       const report = result.report;
-      if (!isRecord(report))
+      if (!isRecord2(report))
         throw new E2eError2("SESSION", "warden perf stop returned no report");
       const sessionId = typeof result.sessionId === "string" ? result.sessionId : "";
       const reportPath = saveReport(deps, result, report, sessionId);
@@ -5764,21 +8933,21 @@ function spawnWarden(bin) {
 }
 
 // ../../packages/e2e/src/runner/artifacts.ts
-import { createHash } from "crypto";
-import { basename, extname, join as join3, relative, sep } from "path";
+import { createHash as createHash2 } from "crypto";
+import { basename, extname, join as join7, relative, sep } from "path";
 var SLUG_MAX = 60;
 function slug(text, fallback = "test") {
   const slugged = text.normalize("NFKD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, SLUG_MAX).replace(/-+$/g, "");
   return slugged === "" ? fallback : slugged;
 }
 function hash6(...parts) {
-  return createHash("sha1").update(parts.join("\x00")).digest("hex").slice(0, 6);
+  return createHash2("sha1").update(parts.join("\x00")).digest("hex").slice(0, 6);
 }
 function attemptDir(out, specId, title, hash) {
-  return join3(out, specId, `${slug(title.join(" "))}-${hash.slice(0, 6)}`);
+  return join7(out, specId, `${slug(title.join(" "))}-${hash.slice(0, 6)}`);
 }
 function screenshotPath(dir, n, name) {
-  return join3(dir, "screenshots", `${String(n).padStart(3, "0")}-${slug(name, "screenshot")}.png`);
+  return join7(dir, "screenshots", `${String(n).padStart(3, "0")}-${slug(name, "screenshot")}.png`);
 }
 var SPEC_EXT = /\.e2e$/;
 function specIdOf(file, specsDir) {
@@ -5795,9 +8964,9 @@ function specIdOf(file, specsDir) {
 }
 
 // ../../packages/e2e/src/devtools/native-log.ts
-import { copyFileSync as copyFileSync2, mkdirSync as mkdirSync4, readdirSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { copyFileSync as copyFileSync3, mkdirSync as mkdirSync7, readdirSync, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname6, join as join8 } from "path";
 var NATIVE_LOG = "native.log";
 var DEFAULT_TIMEOUT_MS5 = 1e4;
 var SLACK_S = 5;
@@ -5806,23 +8975,23 @@ function realNativeFs() {
   return {
     listReports: (dir) => {
       try {
-        return readdirSync(dir).map((name) => ({ name, mtimeMs: statSync(join4(dir, name)).mtimeMs }));
+        return readdirSync(dir).map((name) => ({ name, mtimeMs: statSync(join8(dir, name)).mtimeMs }));
       } catch {
         return [];
       }
     },
     copy: (from, to) => {
-      mkdirSync4(dirname3(to), { recursive: true });
-      copyFileSync2(from, to);
+      mkdirSync7(dirname6(to), { recursive: true });
+      copyFileSync3(from, to);
     },
     write: (path, text) => {
-      mkdirSync4(dirname3(path), { recursive: true });
+      mkdirSync7(dirname6(path), { recursive: true });
       writeFileSync2(path, text);
     }
   };
 }
 function realNativeLogDeps(exec, adb) {
-  return { exec, adb, fs: realNativeFs(), reportsDir: join4(homedir(), "Library", "Logs", "DiagnosticReports") };
+  return { exec, adb, fs: realNativeFs(), reportsDir: join8(homedir(), "Library", "Logs", "DiagnosticReports") };
 }
 function tail(text) {
   return text.length > MAX_BYTES ? text.slice(text.length - MAX_BYTES) : text;
@@ -5838,7 +9007,7 @@ async function iosProcessName(target, exec, timeoutMs) {
   const app = container.stdout.trim();
   if (container.exitCode !== 0 || !app)
     return { error: failed(`app container of ${target.bundleId}`, container) };
-  const name = await exec(["plutil", "-extract", "CFBundleExecutable", "raw", "-o", "-", join4(app, "Info.plist")], {
+  const name = await exec(["plutil", "-extract", "CFBundleExecutable", "raw", "-o", "-", join8(app, "Info.plist")], {
     timeoutMs
   });
   const exe = name.stdout.trim();
@@ -5867,7 +9036,7 @@ async function iosNativeLog(target, deps, win, timeoutMs) {
     `process == "${proc.exe}"`
   ], { timeoutMs });
   if (show.exitCode === 0) {
-    deps.fs.write(join4(win.dir, NATIVE_LOG), tail(show.stdout));
+    deps.fs.write(join8(win.dir, NATIVE_LOG), tail(show.stdout));
     capture.files.push(NATIVE_LOG);
   } else {
     capture.problems.push(`native log: ${failed("log show", show)}`);
@@ -5875,7 +9044,7 @@ async function iosNativeLog(target, deps, win, timeoutMs) {
   for (const report of deps.fs.listReports(deps.reportsDir)) {
     if (!report.name.startsWith(proc.exe) || !report.name.endsWith(".ips") || report.mtimeMs < win.sinceMs)
       continue;
-    deps.fs.copy(join4(deps.reportsDir, report.name), join4(win.dir, report.name));
+    deps.fs.copy(join8(deps.reportsDir, report.name), join8(win.dir, report.name));
     capture.files.push(report.name);
   }
   return capture;
@@ -5897,7 +9066,7 @@ async function androidNativeLog(target, deps, win, timeoutMs) {
     crash.exitCode === 0 ? `--- crash buffer ---
 ${crash.stdout}` : ""
   ];
-  deps.fs.write(join4(win.dir, NATIVE_LOG), tail(sections.filter(Boolean).join(`
+  deps.fs.write(join8(win.dir, NATIVE_LOG), tail(sections.filter(Boolean).join(`
 `)));
   capture.files.push(NATIVE_LOG);
   return capture;
@@ -5911,24 +9080,6 @@ async function captureNativeLog(target, deps, win) {
   }
 }
 
-// ../../packages/e2e/src/runner/callsite.ts
-import { join as join5 } from "path";
-var OWN_FILES = new Set(["callsite.ts", "scope.ts", "test.ts", "attempt.ts"].map((name) => join5(import.meta.dir, name)).concat(join5(import.meta.dir, "..", "index.ts")));
-var FRAME = /(?:\(|\s)((?:file:\/\/)?\/[^\s()]+?):\d+(?::\d+)?\)?\s*$/;
-function callerFile(stack = new Error().stack) {
-  for (const line of (stack ?? "").split(`
-`)) {
-    const raw = FRAME.exec(line)?.[1];
-    if (raw === undefined)
-      continue;
-    const path = raw.startsWith("file://") ? raw.slice("file://".length) : raw;
-    if (OWN_FILES.has(path) || path.includes("/node_modules/"))
-      continue;
-    return path;
-  }
-  return "unknown";
-}
-
 // ../../packages/e2e/src/runner/scope.ts
 var BUN_TIMEOUT_MARGIN_MS2 = 30000;
 var hookOwners = new WeakMap;
@@ -6005,7 +9156,8 @@ function registrationDefaults(env = process.env) {
     timeoutMs: parsed?.timeoutMs ?? DEFAULT_TIMEOUT_MS4,
     actionTimeoutMs: parsed?.actionTimeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS,
     assertionTimeoutMs: parsed?.assertionTimeoutMs ?? DEFAULT_ASSERTION_TIMEOUT_MS,
-    platform: parsed?.platform
+    platform: parsed?.platform,
+    deviceKind: parsed?.deviceKind
   };
 }
 var ONLY_KEY = Symbol.for("@delacour/warden-e2e/only");
@@ -6018,6 +9170,6 @@ function onlyWasSeen() {
 
 // ../../packages/e2e/src/version.ts
 var WORKSPACE_VERSION = "0.0.0-workspace";
-var WARDEN_E2E_VERSION2 = "0.6.0";
+var WARDEN_E2E_VERSION2 = "0.8.0";
 
-export { E2eError2, noteSpanDetail, addSpanDetail, canObserve, canDetectAlerts, settleDetailOf, DEFAULT_SETTLE_QUIET_MS, DEFAULT_SETTLE_TIMEOUT_MS, settleByHash, snapshotHash, ok, err, swipeVector, screenRect, fieldValue, PINCH_MS, ROTATE_MS, PATH_MS, centreOf, pinchRadius, rotateRadius, requireGesture, assertScale, assertDegrees, isInteractiveRole, resolveRole, normalizeText, matchesText, indexSnapshot, testIdQuery, textQuery, roleQuery, selectorExpression, renderSnapshot, renderHeader, resolve, locateByTestIdViaReact, isLocator, Locator, pickOne, textOf, scrollUntilVisible, bunExec, execError, driverError, driverErr, logEventSchema, fatalEventSchema, responseSchema, mapWireError, encodeRequest, bunSpawn, stdioTransport, spawnSimd, connectSimd, isHidLost, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, parseBudgets, createDevicePerf, perfStartFor, spawnWarden, hash6, attemptDir, screenshotPath, specIdOf, realNativeLogDeps, captureNativeLog, callerFile, BUN_TIMEOUT_MARGIN_MS2, ownHook, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION2 };
+export { E2eError2, registerA11yTarget, a11yTargetOf, canActOnElements, noteSpanDetail, addSpanDetail, canObserve, canDetectAlerts, settleDetailOf, DEFAULT_SETTLE_QUIET_MS, DEFAULT_SETTLE_TIMEOUT_MS, settleByHash, snapshotHash, ok, err, swipeVector, screenRect, fieldValue, PINCH_MS, ROTATE_MS, PATH_MS, centreOf, pinchRadius, rotateRadius, requireGesture, assertScale, assertDegrees, isInteractiveRole, resolveRole, normalizeText, matchesText, indexSnapshot, testIdQuery, textQuery, roleQuery, selectorExpression, renderSnapshot, renderHeader, resolve, locateByTestIdViaReact, isLocator, Locator, pickOne, textOf, scrollUntilVisible, bunExec, execError, driverError, driverErr, logEventSchema, fatalEventSchema, responseSchema, mapWireError, createLineSplitter, encodeRequest, bunSpawn, stdioTransport, socketTransport, createSimdClient, spawnSimd, connectSimd, isRecoverableLoss, CAMERA_FACINGS, CONDITION_AREAS, resolveNetwork, resolveTextSize, androidFontScale, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, accessibleName, announce, failing, formatIssues, toE2eError, settled, unwrap, parseUiadA11yEvents, parseInjectEvents, withA11yRead, renderA11yScreen, createDeviceA11y, IOS_DEVICE_CAPABILITIES, sniffCameraMedia, cameraFeedDir, clearCameraFeeds, isLeaseAlive, processAlive, describeOwner, isPhysicalIosId, wardenHome, defaultDbPath, ownerKey, openStore, callerFile, formatCoord, DEFAULT_SPEED_MPS, DEFAULT_INTERVAL_S, realTickerClock, startRouteTicker, startFlap, registerConditions, conditionsOf, conditionSinkFor, createDeviceConditions, parseBudgets, createDevicePerf, perfStartFor, spawnWarden, hash6, attemptDir, screenshotPath, specIdOf, realNativeLogDeps, captureNativeLog, BUN_TIMEOUT_MARGIN_MS2, ownHook, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION2 };