@delacour/warden-e2e 0.7.0 → 0.9.0

package/{chunk-empqr9n0.mjs → chunk-y0y7frfz.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);
     }
   });
@@ -4524,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;
@@ -4543,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 }
         })
       };
     }
@@ -5067,8 +5112,41 @@ function traceDriver(driver, options) {
   return wrap(driver, "driver.");
 }
 
-// ../../packages/core/src/conditions/conditions.config.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 };
@@ -5110,6 +5188,7 @@ var TEXT_SIZE_NAMES = [
   "accessibility-extra-extra-large",
   "accessibility-extra-extra-extra-large"
 ];
+var CAMERA_FACINGS = ["back", "front"];
 var CONDITION_AREAS = [
   "network",
   "location",
@@ -5117,7 +5196,8 @@ var CONDITION_AREAS = [
   "permission",
   "locale",
   "a11y",
-  "battery"
+  "battery",
+  "camera"
 ];
 
 // ../../packages/core/src/conditions/network.presets.ts
@@ -5227,43 +5307,62 @@ function appliedA11y(op, applied) {
 
 // ../../packages/core/src/conditions/conditions.config.ts
 var NETWORK_WORDS = ["online", "offline", ...NETWORK_PRESET_NAMES];
-var nonNegative2 = z7.number().nonnegative().finite();
-var customNetworkSchema = z7.object({
+var nonNegative2 = z8.number().nonnegative().finite();
+var customNetworkSchema = z8.object({
   latencyMs: nonNegative2.optional(),
   jitterMs: nonNegative2.optional(),
   downKbps: nonNegative2.optional(),
   upKbps: nonNegative2.optional(),
-  lossPct: z7.number().min(0).max(100).optional()
+  lossPct: z8.number().min(0).max(100).optional()
 }).strict();
-var isoDate = z7.string().refine((v) => !Number.isNaN(Date.parse(v)), { message: "invalid date (use ISO 8601)" });
-var offsetDuration = z7.string().refine((v) => parseDuration(v).success, { message: "invalid duration (use e.g. 2d)" });
-var textSize = z7.union([z7.enum(TEXT_SIZE_NAMES), z7.number().positive().finite()]);
-var a11yConfigSchema = z7.object({
+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: z7.boolean().optional(),
-  contrast: z7.enum(["increased", "normal"]).optional(),
-  reduceMotion: z7.boolean().optional()
+  boldText: z8.boolean().optional(),
+  contrast: z8.enum(["increased", "normal"]).optional(),
+  reduceMotion: z8.boolean().optional()
 }).strict();
-var conditionsConfigSchema = z7.object({
-  network: z7.union([z7.enum(NETWORK_WORDS), customNetworkSchema]).optional(),
-  location: z7.union([
-    z7.enum(["city-run", "city-bike", "freeway"]),
-    z7.object({
-      lat: z7.number().min(-90).max(90),
-      lon: z7.number().min(-180).max(180),
-      altM: z7.number().finite().optional()
+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: z7.union([
+  clock: z8.union([
     isoDate,
-    z7.object({ at: isoDate, frozen: z7.boolean().optional() }).strict(),
-    z7.object({ offset: offsetDuration }).strict()
+    z8.object({ at: isoDate, frozen: z8.boolean().optional() }).strict(),
+    z8.object({ offset: offsetDuration }).strict()
   ]).optional(),
-  permissions: z7.partialRecord(z7.enum(PERMISSION_NAMES), z7.enum(["granted", "denied", "unset"])).optional(),
-  locale: z7.string().min(1).optional(),
-  timezone: z7.string().min(1).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") {
@@ -5334,7 +5433,7 @@ function parseConditionsEnv(raw) {
 }
 
 // ../../packages/e2e/src/env.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var ENV_NAMES = {
   udid: "WARDEN_UDID",
   deviceName: "WARDEN_DEVICE_NAME",
@@ -5343,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",
@@ -5363,66 +5463,86 @@ var ENV_NAMES = {
   conditions: "WARDEN_CONDITIONS",
   leaseId: "WARDEN_LEASE_ID",
   netproxyCommand: "WARDEN_NETPROXY_COMMAND",
-  biometrics: "WARDEN_BIOMETRICS"
+  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 = z8.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
-var millis = z8.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z8.number().int().positive());
-var launchArgs = z8.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 = z8.array(z8.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 z8.NEVER;
+  return z9.NEVER;
 });
-var conditions = z8.string().transform((raw, ctx) => {
+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 z8.NEVER;
+  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 = z8.object({
-  udid: z8.string().min(1),
-  deviceName: z8.string().optional(),
-  platform: z8.enum(["ios", "android"]).default("ios"),
-  bundleId: z8.string({ error: REQUIRED }).min(1, REQUIRED),
-  appPath: z8.string().optional(),
-  metroUrl: z8.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: z8.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: z8.string().optional(),
-  helperDir: z8.string().optional(),
-  simd: z8.string().optional(),
-  simdSocket: z8.string().optional(),
-  iosRunnerSocket: z8.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: z8.enum(["physical"]).optional(),
+  deviceKind: z9.enum(["physical"]).optional(),
   iosRunnerRestart: launchArgs.optional(),
   afterReboot: launchArgs.optional(),
-  version: z8.string().optional(),
-  bin: z8.string().optional(),
-  perf: z8.string().optional(),
-  perfBudgets: z8.string().optional(),
+  version: z9.string().optional(),
+  bin: z9.string().optional(),
+  perf: z9.string().optional(),
+  perfBudgets: z9.string().optional(),
   conditions: conditions.optional(),
-  leaseId: z8.string().min(1).optional(),
-  netproxyCommand: launchArgs.pipe(z8.array(z8.string()).min(1)).optional(),
-  biometrics: toggle.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 = z8.array(z8.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 {}
@@ -5443,6 +5563,7 @@ 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,
@@ -5457,6 +5578,8 @@ function toEnv(v, now) {
     ...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 ? {} : {
@@ -5489,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 z9 } from "zod";
-var testStatusSchema = z9.enum(["passed", "failed", "skipped", "timed-out"]);
-var testResultSchema = z9.object({
-  file: z9.string(),
-  title: z9.array(z9.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: z9.number(),
-  startedAt: z9.number(),
-  only: z9.boolean().optional(),
-  error: z9.object({
-    message: z9.string(),
-    code: z9.string().optional(),
-    stack: z9.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: z9.object({ dir: z9.string(), files: z9.array(z9.string()) }).optional(),
-  device: z9.object({
-    udid: z9.string(),
-    platform: z9.enum(["ios", "android"]),
-    name: z9.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) {
@@ -5935,19 +6058,624 @@ function getSession(opts = {}) {
   return session;
 }
 
-// ../../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/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 descendantTexts(el, platform, out) {
+  for (const child of el.children) {
+    if (child.hidden)
+      continue;
+    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);
+  }
+}
+function hasActionableDescendant(el, platform) {
+  return el.children.some((c) => !c.hidden && (isActionable(c, platform) || hasActionableDescendant(c, platform)));
+}
+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 (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:
+  }
+  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/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);
+}
+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);
+}
+
+// ../../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/conditions/device-conditions.ts
-import { resolve as resolve3 } from "path";
+// ../../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"]);
@@ -6000,14 +6728,1048 @@ async function unwrap(call, action, signal) {
   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 mkdirSync3 } from "fs";
-import { dirname as dirname3 } from "path";
+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) {
-      mkdirSync3(dirname3(path), { recursive: true });
+      mkdirSync5(dirname4(path), { recursive: true });
       ready = true;
     }
     appendFileSync2(path, `${JSON.stringify(event)}
@@ -6022,7 +7784,8 @@ var KNOWN_AREAS = new Set([
   "permission",
   "locale",
   "a11y",
-  "battery"
+  "battery",
+  "camera"
 ]);
 
 // ../../packages/e2e/src/conditions/geo.ts
@@ -6350,12 +8113,28 @@ function locationOf(input) {
   validatePoint(input);
   return { kind: "point", lat: input.lat, lon: input.lon };
 }
-var registry = new WeakMap;
+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) {
-  registry.set(device, internals);
+  registry2.set(device, internals);
 }
 function conditionsOf(device) {
-  return registry.get(device);
+  return registry2.get(device);
 }
 function conditionSinkFor(session) {
   return session.results === undefined ? undefined : openConditionSink(session.results.path);
@@ -6379,6 +8158,8 @@ function createDeviceConditions(deps) {
   let localeDirty = false;
   let a11yDirty = false;
   let batteryDirty = false;
+  let cameraDirty = false;
+  let currentCamera = {};
   const permissionStates = new Map;
   let permissionBundle;
   let currentLocale = {};
@@ -6728,6 +8509,12 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
       ...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
@@ -6747,6 +8534,68 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
     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`);
@@ -6787,10 +8636,10 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
       throw new E2eError2("ACTION_FAILED", `a network flap or timeline stopped on its own after failing: ${failures[0]}`);
     }
   }
-  const declared = baseline.network !== undefined || baseline.location !== undefined || baseline.clock !== undefined || baseline.permissions !== undefined || baseline.locale !== undefined || baseline.timezone !== undefined || baseline.a11y !== undefined;
+  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 || runs.size > 0,
+    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) {
@@ -6810,6 +8659,9 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
         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;
@@ -6863,6 +8715,12 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
           batteryDirty = false;
         });
       }
+      if (cameraDirty) {
+        await attempt(async () => {
+          await applyCamera(baselineCamera());
+          cameraDirty = false;
+        });
+      }
       if (errors.length > 0)
         throw errors[0];
     }
@@ -6876,6 +8734,7 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
     locale: applyLocale,
     a11y: applyA11y,
     battery: applyBattery,
+    camera: cameraApi,
     memoryWarning: async (options) => {
       const op = settingOp("memoryWarning");
       await call("memoryWarning", () => op(options ?? { bundleId: env.bundleId }));
@@ -6890,8 +8749,8 @@ the app runs without the warden network dylib: declare \`conditions.network\` fo
 }
 
 // ../../packages/e2e/src/perf/device-perf.ts
-import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync } from "fs";
-import { join as join2 } from "path";
+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"];
@@ -6980,30 +8839,30 @@ var flagsOf = (o) => [
   ...o.reset ? ["--reset"] : [],
   ...o.maxDurationMs === undefined ? [] : ["--max-duration", `${Math.ceil(o.maxDurationMs / 1000)}s`]
 ];
-var isRecord = (v) => typeof v === "object" && v !== null;
+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 = join2(attempt, PERF_DIR);
-  mkdirSync4(out, { recursive: true });
+  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 && existsSync3(from))
-      copyFileSync(from, join2(out, name));
+    if (from !== undefined && existsSync4(from))
+      copyFileSync2(from, join6(out, name));
     else if (fallback !== undefined)
-      writeFileSync(join2(out, name), fallback);
+      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 : join2(sessionDir, "report.md"));
+  write("report.md", sessionDir === undefined ? undefined : join6(sessionDir, "report.md"));
   write("session.json", undefined, `${JSON.stringify({ sessionId, dir: sessionDir }, null, 2)}
 `);
-  return join2(out, "report.json");
+  return join6(out, "report.json");
 }
 function createDevicePerf(deps) {
   const run = async (sub, extra) => {
@@ -7015,7 +8874,7 @@ function createDevicePerf(deps) {
       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 {
@@ -7037,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);
@@ -7074,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) {
@@ -7105,9 +8964,9 @@ function specIdOf(file, specsDir) {
 }
 
 // ../../packages/e2e/src/devtools/native-log.ts
-import { copyFileSync as copyFileSync2, mkdirSync as mkdirSync5, 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 dirname4, 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;
@@ -7116,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) => {
-      mkdirSync5(dirname4(to), { recursive: true });
-      copyFileSync2(from, to);
+      mkdirSync7(dirname6(to), { recursive: true });
+      copyFileSync3(from, to);
     },
     write: (path, text) => {
-      mkdirSync5(dirname4(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;
@@ -7148,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();
@@ -7177,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)}`);
@@ -7185,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;
@@ -7207,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;
@@ -7221,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;
@@ -7329,6 +9170,6 @@ function onlyWasSeen() {
 
 // ../../packages/e2e/src/version.ts
 var WORKSPACE_VERSION = "0.0.0-workspace";
-var WARDEN_E2E_VERSION2 = "0.7.0";
+var WARDEN_E2E_VERSION2 = "0.9.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, isRecoverableLoss, CONDITION_AREAS, resolveNetwork, resolveTextSize, androidFontScale, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, IOS_DEVICE_CAPABILITIES, toE2eError, settled, unwrap, formatCoord, DEFAULT_SPEED_MPS, DEFAULT_INTERVAL_S, realTickerClock, startRouteTicker, startFlap, registerConditions, conditionsOf, conditionSinkFor, createDeviceConditions, 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 };