@delacour/warden-e2e 0.6.0 → 0.7.0

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

@@ -3076,6 +3076,9 @@ function describeDevices(targets) {
   }
   return [...seen.values()].join(", ");
 }
+function sameDeviceName(served, wanted) {
+  return wanted !== undefined && served.replaceAll("+", " ") === wanted.replaceAll("+", " ");
+}
 function normalizeWsUrl(wsUrl, metroUrl) {
   const ws = new URL(wsUrl);
   const metro = new URL(metroUrl);
@@ -3094,7 +3097,11 @@ function selectTarget(targets, query, metroUrl) {
       (t) => t.reactNative?.logicalDeviceId === query.logicalDeviceId || urlDevice(t) === query.logicalDeviceId,
       "logicalDeviceId"
     ],
-    [query.deviceName, (t) => t.deviceName === query.deviceName, "deviceName"]
+    [
+      query.deviceName,
+      (t) => t.deviceName !== undefined && sameDeviceName(t.deviceName, query.deviceName),
+      "deviceName"
+    ]
   ];
   for (const [value, matches, label] of wanted) {
     if (!value)
@@ -4390,7 +4397,9 @@ var DRIVER_CODES = new Set([
   "E_HID",
   "E_IO",
   "E_BAD_REQUEST",
-  "E_INTERNAL"
+  "E_INTERNAL",
+  "E_DEVICE_LOCKED",
+  "E_REFUSED"
 ]);
 function isDriverCode(code) {
   return DRIVER_CODES.has(code);
@@ -4914,6 +4923,22 @@ function isHidLost(error) {
   const hidInvalidated = /\bE_HID\b/.test(error.message) && /dtuhidd connection[\s\S]*invalidated/.test(error.message);
   return hidInvalidated || /\bE_NOT_BOOTED\b/.test(error.message);
 }
+function isRunnerLost(error) {
+  if (!(error instanceof E2eError2) || error.code !== "ACTION_FAILED" && error.code !== "DRIVER")
+    return false;
+  return /\bE_HELPER_CRASHED\b/.test(error.message);
+}
+function isRecoverableLoss(error, deviceKind) {
+  return deviceKind === "physical" ? isRunnerLost(error) : isHidLost(error);
+}
+var RUNNER_RESTART_MS = 180000;
+async function restartRunnerHost(deps, argv, udid) {
+  if (argv === undefined || argv.length === 0)
+    return err("WARDEN_IOS_RUNNER_RESTART is not set");
+  const cmd = argv.map((arg) => arg.replaceAll("{udid}", udid));
+  const res = await deps.exec(cmd, { timeoutMs: RUNNER_RESTART_MS });
+  return res.exitCode === 0 ? ok(undefined) : err(execError(cmd, res));
+}
 async function rebootSim(deps, udid) {
   const down = ["xcrun", "simctl", "shutdown", udid];
   const shutdown = await deps.exec(down, { timeoutMs: SHUTDOWN_MS });
@@ -5042,8 +5067,274 @@ function traceDriver(driver, options) {
   return wrap(driver, "driver.");
 }
 
-// ../../packages/e2e/src/env.ts
+// ../../packages/core/src/conditions/conditions.config.ts
 import { z as z7 } from "zod";
+
+// ../../packages/core/src/duration.ts
+var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
+function parseDuration(input) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/.exec(input.trim());
+  if (!match?.[1])
+    return { success: false, error: `invalid duration "${input}" (use e.g. 30s, 10m, 2h)` };
+  return { success: true, data: Math.round(Number(match[1]) * (UNIT_MS[match[2] ?? "s"] ?? 1000)) };
+}
+
+// ../../packages/core/src/conditions/conditions.types.ts
+var PERMISSION_NAMES = [
+  "location",
+  "locationAlways",
+  "camera",
+  "photos",
+  "photosAdd",
+  "contacts",
+  "contactsLimited",
+  "notifications",
+  "microphone",
+  "calendar",
+  "reminders",
+  "motion",
+  "mediaLibrary",
+  "siri"
+];
+var TEXT_SIZE_NAMES = [
+  "extra-small",
+  "small",
+  "medium",
+  "large",
+  "extra-large",
+  "extra-extra-large",
+  "extra-extra-extra-large",
+  "accessibility-medium",
+  "accessibility-large",
+  "accessibility-extra-large",
+  "accessibility-extra-extra-large",
+  "accessibility-extra-extra-extra-large"
+];
+var CONDITION_AREAS = [
+  "network",
+  "location",
+  "clock",
+  "permission",
+  "locale",
+  "a11y",
+  "battery"
+];
+
+// ../../packages/core/src/conditions/network.presets.ts
+var NETWORK_PRESET_NAMES = ["edge", "3g", "4g", "lte", "wifi", "slow", "lossy"];
+var NETWORK_PRESETS = {
+  edge: {
+    emu: { speed: "200:240", delay: "175:225" },
+    shaping: { latencyMs: 400, jitterMs: 25, downKbps: 240, upKbps: 200, lossPct: 0 }
+  },
+  "3g": {
+    emu: { speed: "330:780", delay: "40:60" },
+    shaping: { latencyMs: 100, jitterMs: 10, downKbps: 780, upKbps: 330, lossPct: 0 }
+  },
+  "4g": {
+    emu: { speed: "9000:9000", delay: "70:100" },
+    shaping: { latencyMs: 170, jitterMs: 15, downKbps: 9000, upKbps: 9000, lossPct: 0 }
+  },
+  lte: {
+    emu: { speed: "10000:50000", delay: "20:30" },
+    shaping: { latencyMs: 50, jitterMs: 5, downKbps: 50000, upKbps: 1e4, lossPct: 0 }
+  },
+  wifi: {
+    emu: { speed: "33000:40000", delay: "0:1" },
+    shaping: { latencyMs: 2, jitterMs: 0, downKbps: 40000, upKbps: 33000, lossPct: 0 }
+  },
+  slow: {
+    emu: { speed: "400:400", delay: "900:1100" },
+    shaping: { latencyMs: 2000, jitterMs: 100, downKbps: 400, upKbps: 400, lossPct: 0 }
+  },
+  lossy: {
+    emu: { speed: "1000:1000", delay: "200:300" },
+    shaping: { latencyMs: 500, jitterMs: 50, downKbps: 1000, upKbps: 1000, lossPct: 10 }
+  }
+};
+var UNSHAPED = { latencyMs: 0, jitterMs: 0, downKbps: 0, upKbps: 0, lossPct: 0 };
+var UNSHAPED_EMU = { speed: "full", delay: "none" };
+var nonNegative = (value) => value === undefined || !Number.isFinite(value) ? 0 : Math.max(0, value);
+function customEmu(shaping) {
+  const { downKbps, upKbps, latencyMs, jitterMs } = shaping;
+  const speed = downKbps === 0 && upKbps === 0 ? UNSHAPED_EMU.speed : `${upKbps || downKbps}:${downKbps || upKbps}`;
+  const half = latencyMs / 2;
+  const min = Math.max(0, Math.round(half - jitterMs));
+  const max = Math.round(half + jitterMs);
+  const delay = max === 0 ? UNSHAPED_EMU.delay : `${min}:${max}`;
+  return { speed, delay };
+}
+function resolveNetwork(condition) {
+  switch (condition.kind) {
+    case "offline":
+      return { online: false };
+    case "online":
+      return { online: true, shaping: UNSHAPED, emu: UNSHAPED_EMU };
+    case "preset":
+      return { online: true, ...NETWORK_PRESETS[condition.preset] };
+    case "flap":
+      return resolveNetwork(condition.base ?? { kind: "online" });
+    case "custom": {
+      const shaping = {
+        latencyMs: nonNegative(condition.latencyMs),
+        jitterMs: nonNegative(condition.jitterMs),
+        downKbps: nonNegative(condition.downKbps),
+        upKbps: nonNegative(condition.upKbps),
+        lossPct: Math.min(100, nonNegative(condition.lossPct))
+      };
+      return { online: true, shaping, emu: customEmu(shaping) };
+    }
+  }
+}
+
+// ../../packages/core/src/conditions/text-size.ts
+var TEXT_SIZE_SCALE = {
+  "extra-small": 0.82,
+  small: 0.88,
+  medium: 0.94,
+  large: 1,
+  "extra-large": 1.12,
+  "extra-extra-large": 1.24,
+  "extra-extra-extra-large": 1.35,
+  "accessibility-medium": 1.6,
+  "accessibility-large": 1.9,
+  "accessibility-extra-large": 2.35,
+  "accessibility-extra-extra-large": 2.75,
+  "accessibility-extra-extra-extra-large": 3.1
+};
+var ANDROID_MAX_FONT_SCALE = 2;
+var ANDROID_MIN_FONT_SCALE = 0.5;
+var isName = (v) => TEXT_SIZE_NAMES.includes(v);
+function resolveTextSize(size) {
+  if (typeof size === "number") {
+    if (!Number.isFinite(size) || size <= 0)
+      return err(`text size must be a positive scale, got ${String(size)}`);
+    let best = TEXT_SIZE_NAMES[0];
+    for (const name of TEXT_SIZE_NAMES) {
+      if (Math.abs(TEXT_SIZE_SCALE[name] - size) < Math.abs(TEXT_SIZE_SCALE[best] - size))
+        best = name;
+    }
+    return ok({ category: best, scale: size });
+  }
+  if (!isName(size))
+    return err(`unknown text size "${String(size)}" (use ${TEXT_SIZE_NAMES.join(", ")} or a scale like 1.3)`);
+  return ok({ category: size, scale: TEXT_SIZE_SCALE[size] });
+}
+var androidFontScale = (scale) => Math.min(ANDROID_MAX_FONT_SCALE, Math.max(ANDROID_MIN_FONT_SCALE, Math.round(scale * 100) / 100));
+function appliedA11y(op, applied) {
+  return Object.fromEntries(Object.entries(op).filter(([key]) => applied.includes(key)));
+}
+
+// ../../packages/core/src/conditions/conditions.config.ts
+var NETWORK_WORDS = ["online", "offline", ...NETWORK_PRESET_NAMES];
+var nonNegative2 = z7.number().nonnegative().finite();
+var customNetworkSchema = z7.object({
+  latencyMs: nonNegative2.optional(),
+  jitterMs: nonNegative2.optional(),
+  downKbps: nonNegative2.optional(),
+  upKbps: nonNegative2.optional(),
+  lossPct: z7.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({
+  textSize: textSize.optional(),
+  boldText: z7.boolean().optional(),
+  contrast: z7.enum(["increased", "normal"]).optional(),
+  reduceMotion: z7.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()
+    }).strict()
+  ]).optional(),
+  clock: z7.union([
+    isoDate,
+    z7.object({ at: isoDate, frozen: z7.boolean().optional() }).strict(),
+    z7.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(),
+  a11y: a11yConfigSchema.optional()
+}).strict();
+var isWord = (v) => NETWORK_WORDS.includes(v);
+function toNetworkCondition(input) {
+  if (typeof input === "string") {
+    if (!isWord(input))
+      return err(`unknown network "${input}" (use ${NETWORK_WORDS.join(", ")})`);
+    if (input === "online" || input === "offline")
+      return ok({ kind: input });
+    return ok({ kind: "preset", preset: input });
+  }
+  if ("kind" in input)
+    return ok(input);
+  return ok({ kind: "custom", ...input });
+}
+function toLocation(input) {
+  if (typeof input === "string")
+    return { kind: "scenario", name: input };
+  return { kind: "point", lat: input.lat, lon: input.lon, ...input.altM === undefined ? {} : { altM: input.altM } };
+}
+function toClock(input) {
+  if (typeof input === "string")
+    return { kind: "fixed", at: new Date(input).toISOString() };
+  if ("offset" in input) {
+    const ms = parseDuration(input.offset);
+    return { kind: "offset", ms: ms.success ? ms.data : 0 };
+  }
+  const at = new Date(input.at).toISOString();
+  return input.frozen === true ? { kind: "frozen", at } : { kind: "fixed", at };
+}
+function normalizeConditions(config) {
+  const conditions = {};
+  if (config.network !== undefined) {
+    const network = toNetworkCondition(config.network);
+    if (!network.success)
+      return network;
+    conditions.network = network.data;
+  }
+  if (config.location !== undefined)
+    conditions.location = toLocation(config.location);
+  if (config.clock !== undefined)
+    conditions.clock = toClock(config.clock);
+  if (config.permissions !== undefined)
+    conditions.permissions = config.permissions;
+  if (config.locale !== undefined)
+    conditions.locale = config.locale;
+  if (config.timezone !== undefined)
+    conditions.timezone = config.timezone;
+  if (config.a11y !== undefined) {
+    const a11y = { ...config.a11y };
+    if (config.a11y.textSize !== undefined) {
+      const size = resolveTextSize(config.a11y.textSize);
+      if (!size.success)
+        return size;
+      a11y.fontScale = size.data.scale;
+    }
+    conditions.a11y = a11y;
+  }
+  return ok({ conditions });
+}
+function parseConditionsEnv(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return err("must be JSON");
+  }
+  const parsed = conditionsConfigSchema.safeParse(json);
+  return parsed.success ? ok(parsed.data) : err(parsed.error.issues.map((i) => i.message).join("; "));
+}
+
+// ../../packages/e2e/src/env.ts
+import { z as z8 } from "zod";
 var ENV_NAMES = {
   udid: "WARDEN_UDID",
   deviceName: "WARDEN_DEVICE_NAME",
@@ -5060,57 +5351,78 @@ var ENV_NAMES = {
   helperDir: "WARDEN_HELPER_DIR",
   simd: "WARDEN_SIMD",
   simdSocket: "WARDEN_SIMD_SOCKET",
+  iosRunnerSocket: "WARDEN_IOS_RUNNER_SOCKET",
   logTimestamps: "WARDEN_LOG_TIMESTAMPS",
+  deviceKind: "WARDEN_DEVICE_KIND",
+  iosRunnerRestart: "WARDEN_IOS_RUNNER_RESTART",
   afterReboot: "WARDEN_AFTER_REBOOT",
   version: "WARDEN_VERSION",
   bin: "WARDEN_BIN",
   perf: "WARDEN_PERF",
-  perfBudgets: "WARDEN_PERF_BUDGETS"
+  perfBudgets: "WARDEN_PERF_BUDGETS",
+  conditions: "WARDEN_CONDITIONS",
+  leaseId: "WARDEN_LEASE_ID",
+  netproxyCommand: "WARDEN_NETPROXY_COMMAND",
+  biometrics: "WARDEN_BIOMETRICS"
 };
 var DEFAULT_TIMEOUT_MS4 = 120000;
 var DEFAULT_ACTION_TIMEOUT_MS = 30000;
 var DEFAULT_ASSERTION_TIMEOUT_MS = 5000;
-var toggle = z7.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
-var millis = z7.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z7.number().int().positive());
-var launchArgs = z7.string().transform((raw, ctx) => {
+var toggle = 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) => {
   try {
-    const parsed = z7.array(z7.string()).safeParse(JSON.parse(raw));
+    const parsed = z8.array(z8.string()).safeParse(JSON.parse(raw));
     if (parsed.success)
       return parsed.data;
   } catch {}
   ctx.addIssue({ code: "custom", message: "must be a JSON array of strings" });
-  return z7.NEVER;
+  return z8.NEVER;
+});
+var conditions = z8.string().transform((raw, ctx) => {
+  const parsed = parseConditionsEnv(raw);
+  if (parsed.success)
+    return parsed.data;
+  ctx.addIssue({ code: "custom", message: parsed.error });
+  return z8.NEVER;
 });
 var REQUIRED = "required when WARDEN_UDID is set";
-var schema = z7.object({
-  udid: z7.string().min(1),
-  deviceName: z7.string().optional(),
-  platform: z7.enum(["ios", "android"]).default("ios"),
-  bundleId: z7.string({ error: REQUIRED }).min(1, REQUIRED),
-  appPath: z7.string().optional(),
-  metroUrl: z7.string().optional(),
+var schema = 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(),
   launchArgs: launchArgs.default([]),
-  out: z7.string().optional(),
+  out: z8.string().optional(),
   timeout: millis.default(DEFAULT_TIMEOUT_MS4),
   actionTimeout: millis.default(DEFAULT_ACTION_TIMEOUT_MS),
   assertionTimeout: millis.default(DEFAULT_ASSERTION_TIMEOUT_MS),
-  specsDir: z7.string().optional(),
-  helperDir: z7.string().optional(),
-  simd: z7.string().optional(),
-  simdSocket: z7.string().optional(),
+  specsDir: z8.string().optional(),
+  helperDir: z8.string().optional(),
+  simd: z8.string().optional(),
+  simdSocket: z8.string().optional(),
+  iosRunnerSocket: z8.string().optional(),
   logTimestamps: toggle.default(false),
+  deviceKind: z8.enum(["physical"]).optional(),
+  iosRunnerRestart: launchArgs.optional(),
   afterReboot: launchArgs.optional(),
-  version: z7.string().optional(),
-  bin: z7.string().optional(),
-  perf: z7.string().optional(),
-  perfBudgets: z7.string().optional()
+  version: z8.string().optional(),
+  bin: z8.string().optional(),
+  perf: z8.string().optional(),
+  perfBudgets: z8.string().optional(),
+  conditions: conditions.optional(),
+  leaseId: z8.string().min(1).optional(),
+  netproxyCommand: launchArgs.pipe(z8.array(z8.string()).min(1)).optional(),
+  biometrics: toggle.optional()
 });
 function defined2(values) {
   return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
 }
 function parseArgv(raw) {
   try {
-    const parsed = z7.array(z7.string()).min(1).safeParse(JSON.parse(raw));
+    const parsed = z8.array(z8.string()).min(1).safeParse(JSON.parse(raw));
     if (parsed.success)
       return parsed.data;
   } catch {}
@@ -5135,9 +5447,16 @@ function toEnv(v, now) {
       helperDir: v.helperDir,
       simd: v.simd,
       simdSocket: v.simdSocket,
+      iosRunnerSocket: v.iosRunnerSocket,
       wardenVersion: v.version,
       perfBudgets: v.perfBudgets
     }),
+    ...v.deviceKind === undefined ? {} : { deviceKind: v.deviceKind },
+    ...v.iosRunnerRestart === undefined ? {} : { iosRunnerRestart: v.iosRunnerRestart },
+    ...v.conditions === undefined ? {} : { conditions: v.conditions },
+    ...v.leaseId === undefined ? {} : { leaseId: v.leaseId },
+    ...v.netproxyCommand === undefined ? {} : { netproxyCommand: v.netproxyCommand },
+    ...v.biometrics === true ? { biometrics: true } : {},
     ...v.afterReboot === undefined ? {} : { afterReboot: v.afterReboot },
     ...v.bin === undefined ? {} : { wardenBin: parseArgv(v.bin) },
     ...v.perf === undefined ? {} : {
@@ -5170,25 +5489,25 @@ function readEnv(env, opts = {}) {
 // ../../packages/e2e/src/runner/results.ts
 import { appendFileSync, mkdirSync } from "fs";
 import { dirname as dirname2 } from "path";
-import { z as z8 } from "zod";
-var testStatusSchema = z8.enum(["passed", "failed", "skipped", "timed-out"]);
-var testResultSchema = z8.object({
-  file: z8.string(),
-  title: z8.array(z8.string()),
+import { z as z9 } from "zod";
+var testStatusSchema = z9.enum(["passed", "failed", "skipped", "timed-out"]);
+var testResultSchema = z9.object({
+  file: z9.string(),
+  title: z9.array(z9.string()),
   status: testStatusSchema,
-  durationMs: z8.number(),
-  startedAt: z8.number(),
-  only: z8.boolean().optional(),
-  error: z8.object({
-    message: z8.string(),
-    code: z8.string().optional(),
-    stack: z8.string().optional()
+  durationMs: z9.number(),
+  startedAt: z9.number(),
+  only: z9.boolean().optional(),
+  error: z9.object({
+    message: z9.string(),
+    code: z9.string().optional(),
+    stack: z9.string().optional()
   }).optional(),
-  artifacts: z8.object({ dir: z8.string(), files: z8.array(z8.string()) }).optional(),
-  device: z8.object({
-    udid: z8.string(),
-    platform: z8.enum(["ios", "android"]),
-    name: z8.string().optional()
+  artifacts: 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()
   })
 });
 function openResults(path) {
@@ -5260,6 +5579,8 @@ async function runStep(attempt, kind, label, fn, now = Date.now) {
 }
 
 // ../../packages/e2e/src/session.ts
+var ENROLL_TRIES = 5;
+var ENROLL_RETRY_MS = 500;
 function devtoolsTarget(env) {
   return { appId: env.bundleId, ...env.deviceName === undefined ? {} : { deviceName: env.deviceName } };
 }
@@ -5366,10 +5687,27 @@ function createSession(opts = {}) {
       await sleep(WARM_INTERVAL_MS);
     }
   }
+  async function recoverRunner(deps, name) {
+    if (hidRecovered) {
+      note(`iPhone ${name}: the runner connection was lost again after a restart; check the phone and retry`);
+      return false;
+    }
+    hidRecovered = true;
+    await resetDevice();
+    const restarted = await restartRunnerHost(deps, resolved.iosRunnerRestart, resolved.udid);
+    if (!restarted.success) {
+      note(`iPhone ${name}: runner connection lost, restart failed: ${restarted.error}`);
+      return false;
+    }
+    note(`iPhone ${name}: runner connection lost, runner host restarted; running the test again`);
+    return true;
+  }
   async function recoverHid() {
     if (hid === undefined || closing !== undefined)
       return false;
     const name = resolved.deviceName ?? resolved.udid;
+    if (resolved.deviceKind === "physical")
+      return recoverRunner(hid, name);
     if (hidRecovered) {
       note(`sim ${name}: HID connection lost again after a reboot; \`warden release <id> --shutdown\` and retry`);
       return false;
@@ -5391,6 +5729,24 @@ function createSession(opts = {}) {
     note(`sim ${name}: HID connection lost (Device Hub quit?), rebooted; running the test again`);
     return true;
   }
+  async function reenroll(driver) {
+    if (resolved.biometrics !== true || resolved.platform !== "ios" || resolved.deviceKind === "physical")
+      return driver;
+    const sleep = hid?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    for (let attempt = 1;attempt <= ENROLL_TRIES; attempt += 1) {
+      const state = await driver.biometrics("enroll");
+      if (!state.success) {
+        note(`biometrics enroll failed: ${state.error.code}: ${state.error.message}`);
+        return driver;
+      }
+      if (state.data.enrolled)
+        return driver;
+      if (attempt < ENROLL_TRIES)
+        await sleep(ENROLL_RETRY_MS);
+    }
+    note(`biometrics enroll did not take after ${ENROLL_TRIES} attempts`);
+    return driver;
+  }
   const session = {
     env: resolved,
     out,
@@ -5423,7 +5779,7 @@ function createSession(opts = {}) {
           throw new E2eError2("DRIVER", `${code}: ${message}`);
         }
         current = cacheObservations(traceDriver(result.data, { trace: () => attempt?.trace }));
-        return current;
+        return reenroll(current);
       }, (cause) => {
         opened = undefined;
         throw new E2eError2("DRIVER", cause instanceof Error ? cause.message : String(cause));
@@ -5579,8 +5935,962 @@ 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/conditions/device-conditions.ts
+import { resolve as resolve3 } from "path";
+
+// ../../packages/e2e/src/driver/unwrap.ts
+var TIMEOUTS = new Set(["E_TIMEOUT", "E_APP_NOT_RESPONDING"]);
+var INFRASTRUCTURE = new Set([
+  "E_HELPER_MISSING",
+  "E_HELPER_CRASHED",
+  "E_NOT_BOOTED",
+  "E_UNKNOWN_DEVICE",
+  "E_AX_UNAVAILABLE",
+  "E_APP_UNAVAILABLE",
+  "E_INTERNAL",
+  "E_DEVICE_LOCKED"
+]);
+function codeFor(code) {
+  if (TIMEOUTS.has(code))
+    return "TIMEOUT";
+  if (INFRASTRUCTURE.has(code))
+    return "DRIVER";
+  return "ACTION_FAILED";
+}
+function toE2eError(error, action) {
+  return new E2eError2(codeFor(error.code), `${action} failed: ${error.code}: ${error.message}`);
+}
+function aborted2(action, signal) {
+  const reason = signal.reason;
+  const detail = reason instanceof Error ? `: ${reason.message}` : "";
+  return new E2eError2("TIMEOUT", `${action} aborted (test deadline reached or cancelled)${detail}`);
+}
+async function settled(call, action, signal) {
+  if (signal === undefined)
+    return call();
+  if (signal.aborted)
+    throw aborted2(action, signal);
+  let onAbort;
+  const abort = new Promise((_, reject) => {
+    onAbort = () => reject(aborted2(action, signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([call(), abort]);
+  } finally {
+    if (onAbort !== undefined)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+async function unwrap(call, action, signal) {
+  const result = await settled(call, action, signal);
+  if (!result.success)
+    throw toE2eError(result.error, action);
+  return result.data;
+}
+
+// ../../packages/e2e/src/conditions/condition-events.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+function openConditionSink(path) {
+  let ready = false;
+  return (event) => {
+    if (!ready) {
+      mkdirSync3(dirname3(path), { recursive: true });
+      ready = true;
+    }
+    appendFileSync2(path, `${JSON.stringify(event)}
+`);
+  };
+}
+var KNOWN_AREAS = new Set([
+  "network",
+  "location",
+  "clock",
+  "faults",
+  "permission",
+  "locale",
+  "a11y",
+  "battery"
+]);
+
+// ../../packages/e2e/src/conditions/geo.ts
+var EARTH_RADIUS_M = 6371008.8;
+var rad = (deg) => deg * Math.PI / 180;
+var deg = (r) => r * 180 / Math.PI;
+function haversineM(a, b) {
+  const dLat = rad(b.lat - a.lat);
+  const dLon = rad(b.lon - a.lon);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(rad(a.lat)) * Math.cos(rad(b.lat)) * Math.sin(dLon / 2) ** 2;
+  return 2 * EARTH_RADIUS_M * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+function interpolate(a, b, f) {
+  if (f <= 0)
+    return a;
+  if (f >= 1)
+    return b;
+  const delta = haversineM(a, b) / EARTH_RADIUS_M;
+  if (delta < 0.000000000001)
+    return a;
+  const sinDelta = Math.sin(delta);
+  const wa = Math.sin((1 - f) * delta) / sinDelta;
+  const wb = Math.sin(f * delta) / sinDelta;
+  const lat1 = rad(a.lat);
+  const lon1 = rad(a.lon);
+  const lat2 = rad(b.lat);
+  const lon2 = rad(b.lon);
+  const x = wa * Math.cos(lat1) * Math.cos(lon1) + wb * Math.cos(lat2) * Math.cos(lon2);
+  const y = wa * Math.cos(lat1) * Math.sin(lon1) + wb * Math.cos(lat2) * Math.sin(lon2);
+  const z = wa * Math.sin(lat1) + wb * Math.sin(lat2);
+  return { lat: deg(Math.atan2(z, Math.hypot(x, y))), lon: deg(Math.atan2(y, x)) };
+}
+function routeSteps(points, speedMps, intervalS) {
+  const first = points[0];
+  if (!first)
+    return [];
+  if (points.length === 1)
+    return [first];
+  const stride = Math.max(speedMps * intervalS, 0.01);
+  const steps = [first];
+  let carried = 0;
+  for (let i = 1;i < points.length; i++) {
+    const from = points[i - 1];
+    const to = points[i];
+    const leg = haversineM(from, to);
+    let at = stride - carried;
+    while (at < leg - 0.000001) {
+      steps.push(interpolate(from, to, at / leg));
+      at += stride;
+    }
+    carried = leg - (at - stride);
+  }
+  const last = points[points.length - 1];
+  if (haversineM(steps[steps.length - 1], last) > 0.001)
+    steps.push(last);
+  else
+    steps[steps.length - 1] = last;
+  return steps;
+}
+function formatCoord(n) {
+  const fixed = n.toFixed(7);
+  return fixed.includes(".") ? fixed.replace(/\.?0+$/, "") : fixed;
+}
+
+// ../../packages/e2e/src/conditions/route-ticker.ts
+var DEFAULT_SPEED_MPS = 20;
+var DEFAULT_INTERVAL_S = 1;
+var MAX_CONSECUTIVE_FAILURES = 3;
+var realTickerClock = {
+  now: () => Date.now(),
+  sleep: (ms, signal) => new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done);
+  })
+};
+function startRouteTicker(route, deps) {
+  const controller = new AbortController;
+  const { signal } = controller;
+  const startedAt = deps.now();
+  const intervalMs = (route.intervalS ?? DEFAULT_INTERVAL_S) * 1000;
+  const steps = routeSteps(route.points, route.speedMps ?? DEFAULT_SPEED_MPS, route.intervalS ?? DEFAULT_INTERVAL_S);
+  function* playlist() {
+    do
+      yield* steps;
+    while (route.loop && steps.length > 0);
+  }
+  const total = steps.length;
+  const pace = async (done) => {
+    if (!route.loop && done >= total)
+      return false;
+    await deps.sleep(Math.max(0, startedAt + done * intervalMs - deps.now()), signal);
+    return true;
+  };
+  const run = async () => {
+    const count = { ticks: 0, failures: 0, index: 0 };
+    let lastError = "";
+    const sendOne = async (step) => {
+      const failure = await deps.fix(step).catch((e) => e instanceof Error ? e.message : String(e));
+      if (!failure) {
+        count.failures = 0;
+        count.ticks++;
+        return true;
+      }
+      lastError = failure;
+      count.failures++;
+      return count.failures < MAX_CONSECUTIVE_FAILURES;
+    };
+    for (const step of playlist()) {
+      if (signal.aborted)
+        return { ticks: count.ticks, stopped: "aborted" };
+      if (!await sendOne(step))
+        return { ticks: count.ticks, stopped: "failed", error: lastError };
+      count.index++;
+      if (!await pace(count.index))
+        break;
+    }
+    return { ticks: count.ticks, stopped: signal.aborted ? "aborted" : "finished" };
+  };
+  return { stop: () => controller.abort(), done: run() };
+}
+
+// ../../packages/e2e/src/conditions/scheduler.ts
+var MAX_CONSECUTIVE_FAILURES2 = 3;
+var ONLINE = { kind: "online" };
+var OFFLINE = { kind: "offline" };
+function seededRng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var messageOf = (e) => e instanceof Error ? e.message : String(e);
+async function attempt(run, what) {
+  if (!run)
+    return `target cannot apply ${what}`;
+  try {
+    const res = await run();
+    return res.success ? undefined : res.error.message;
+  } catch (e) {
+    return messageOf(e);
+  }
+}
+function core() {
+  const controller = new AbortController;
+  return { controller, signal: controller.signal, status: { state: "running", transitions: 0 }, transitions: 0 };
+}
+function invalid(message) {
+  return {
+    stop: () => {
+      return;
+    },
+    done: Promise.resolve({ transitions: 0, stopped: "failed", error: message }),
+    current: () => ({ state: "failed", transitions: 0, error: message })
+  };
+}
+function conclude(state, end, error) {
+  const { transitions } = state;
+  if (error !== undefined) {
+    state.status = { state: "failed", transitions, error };
+    return { transitions, stopped: "failed", error };
+  }
+  state.status = { state: end === "finished" ? "finished" : "stopped", transitions };
+  return { transitions, stopped: end };
+}
+function applier(target, deps, state) {
+  const net = target.network?.bind(target);
+  const loc = target.location?.bind(target);
+  const tally = { failures: 0, lastError: "" };
+  const record = async (run, what) => {
+    const failure = await attempt(run, what);
+    if (failure) {
+      tally.failures++;
+      tally.lastError = failure;
+      return false;
+    }
+    tally.failures = 0;
+    state.transitions++;
+    return true;
+  };
+  return {
+    tally,
+    async network(condition) {
+      const landed = await record(net && (() => net(condition)), "network");
+      if (landed)
+        deps.sink?.({ type: "condition", area: "network", value: condition, at: deps.now() });
+      return landed;
+    },
+    async location(op) {
+      const landed = await record(loc && (() => loc(op)), "location");
+      if (landed)
+        deps.sink?.({ type: "condition", area: "location", value: op, at: deps.now() });
+      return landed;
+    }
+  };
+}
+function startFlap(target, options, deps) {
+  if (!(options.upMs > 0 && options.downMs > 0 && Number.isFinite(options.upMs + options.downMs))) {
+    return invalid("flap needs upMs and downMs above 0");
+  }
+  if (options.base?.kind === "flap")
+    return invalid("flap base cannot itself be a flap");
+  const base = options.base ?? ONLINE;
+  const rng = deps.rng ?? seededRng(options.seed ?? 1);
+  const jitter = (options.jitterPct ?? 0) / 100;
+  const state = core();
+  const { signal } = state;
+  const apply = applier(target, deps, state);
+  const stretch = (ms) => Math.max(1, ms * (1 + (rng() * 2 - 1) * jitter));
+  const runPhase = async (phase, skipApply, deadline) => {
+    const landed = skipApply || await apply.network(phase === "up" ? base : OFFLINE);
+    state.status = { state: "running", transitions: state.transitions, phase };
+    const next = deadline + stretch(phase === "up" ? options.upMs : options.downMs);
+    await deps.sleep(Math.max(0, next - deps.now()), signal);
+    return [landed && phase === "up", next];
+  };
+  const run = async () => {
+    let phase = "up";
+    let atBase = false;
+    let deadline = deps.now();
+    let skipApply = options.applyInitial === false;
+    while (!signal.aborted && apply.tally.failures < MAX_CONSECUTIVE_FAILURES2) {
+      [atBase, deadline] = await runPhase(phase, skipApply, deadline);
+      skipApply = false;
+      phase = phase === "up" ? "down" : "up";
+    }
+    const { failures, lastError } = apply.tally;
+    if (!atBase)
+      await apply.network(base);
+    return conclude(state, "aborted", failures >= MAX_CONSECUTIVE_FAILURES2 ? lastError : undefined);
+  };
+  return { stop: () => state.controller.abort(), done: run(), current: () => state.status };
+}
+function startTimeline(target, steps, deps) {
+  if (steps.some((s) => !(s.atMs >= 0) || !Number.isFinite(s.atMs)))
+    return invalid("timeline atMs must be 0 or more");
+  const ordered = [...steps].sort((a, b) => a.atMs - b.atMs);
+  const startedAt = deps.now();
+  const state = core();
+  const { signal } = state;
+  const apply = applier(target, deps, state);
+  const runStep = async (step) => {
+    const errors = [];
+    if (step.network && !await apply.network(step.network))
+      errors.push(apply.tally.lastError);
+    if (step.location && !await apply.location(step.location))
+      errors.push(apply.tally.lastError);
+    return errors.length > 0 ? errors.join("; ") : undefined;
+  };
+  const run = async () => {
+    let stepFailures = 0;
+    let lastError = "";
+    for (const [index, step] of ordered.entries()) {
+      await deps.sleep(Math.max(0, startedAt + step.atMs - deps.now()), signal);
+      if (signal.aborted)
+        break;
+      state.status = { state: "running", transitions: state.transitions, step: index };
+      const problem = await runStep(step);
+      stepFailures = problem === undefined ? 0 : stepFailures + 1;
+      lastError = problem ?? lastError;
+      if (stepFailures >= MAX_CONSECUTIVE_FAILURES2)
+        return conclude(state, "aborted", lastError);
+    }
+    return conclude(state, signal.aborted ? "aborted" : "finished");
+  };
+  return { stop: () => state.controller.abort(), done: run(), current: () => state.status };
+}
+
+// ../../packages/e2e/src/conditions/device-conditions.ts
+var ONLINE2 = { kind: "online" };
+var REAL_CLOCK = { kind: "real" };
+function a11yOpOf(config) {
+  const { fontScale: _scale, ...op } = config;
+  return op;
+}
+var stderrLog = (line) => {
+  process.stderr.write(`${line}
+`);
+};
+function invalid2(message) {
+  return new E2eError2("INVALID_ARGUMENT", message);
+}
+function durationMs(value, what) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0)
+      throw invalid2(`${what} must be 0 or more, got ${String(value)}`);
+    return value;
+  }
+  const parsed = parseDuration(value);
+  if (!parsed.success)
+    throw invalid2(`${what}: ${parsed.error}`);
+  return parsed.data;
+}
+function network(input) {
+  const condition = toNetworkCondition(input);
+  if (!condition.success)
+    throw invalid2(condition.error);
+  return condition.data;
+}
+function instant(at) {
+  const date = at instanceof Date ? new Date(at.getTime()) : new Date(at);
+  if (Number.isNaN(date.getTime()))
+    throw invalid2(`invalid time ${JSON.stringify(at)} (use an ISO 8601 string, a Date or epoch ms)`);
+  return date;
+}
+function validatePoint(point) {
+  const ok = Number.isFinite(point.lat) && Number.isFinite(point.lon) && Math.abs(point.lat) <= 90 && Math.abs(point.lon) <= 180;
+  if (!ok)
+    throw invalid2(`invalid location ${point.lat},${point.lon} (lat within 90, lon within 180)`);
+}
+var SCENARIOS = ["city-run", "city-bike", "freeway"];
+function locationOf(input) {
+  if ("kind" in input)
+    return input;
+  validatePoint(input);
+  return { kind: "point", lat: input.lat, lon: input.lon };
+}
+var registry = new WeakMap;
+function registerConditions(device, internals) {
+  registry.set(device, internals);
+}
+function conditionsOf(device) {
+  return registry.get(device);
+}
+function conditionSinkFor(session) {
+  return session.results === undefined ? undefined : openConditionSink(session.results.path);
+}
+function createDeviceConditions(deps) {
+  const { driver, env } = deps;
+  const ticker = deps.tickerClock ?? realTickerClock;
+  const log = deps.log ?? stderrLog;
+  const normalized = normalizeConditions(env.conditions ?? {});
+  if (!normalized.success)
+    throw new E2eError2("SESSION", `invalid conditions: ${normalized.error}`);
+  const baseline = normalized.data.conditions;
+  let currentNetwork = ONLINE2;
+  let currentFaults = [];
+  let currentClock = REAL_CLOCK;
+  let clockSetAt = ticker.now();
+  let networkDirty = false;
+  let locationDirty = false;
+  let clockDirty = false;
+  let permissionsDirty = false;
+  let localeDirty = false;
+  let a11yDirty = false;
+  let batteryDirty = false;
+  const permissionStates = new Map;
+  let permissionBundle;
+  let currentLocale = {};
+  let currentA11y = {};
+  let flap;
+  const runs = new Set;
+  const recorder = deps.recorder;
+  const emit = (event) => {
+    deps.sink?.({ ...event, type: "condition", at: ticker.now() });
+  };
+  async function call(what, run) {
+    const result = await settled(run, what, deps.signal());
+    if (result.success)
+      return result.data;
+    const error = toE2eError(result.error, what);
+    if (result.error.code === "E_NETWORK_RELAUNCH") {
+      throw new E2eError2(error.code, `${error.message}
+the app runs without the warden network dylib: declare \`conditions.network\` for the suite so it launches with it, or pass { relaunch: true }`);
+    }
+    throw error;
+  }
+  const target = (options) => ({
+    network: async (condition) => {
+      const result = await driver.network(condition, options?.relaunch === undefined ? undefined : { relaunch: options.relaunch });
+      if (result.success)
+        recorder?.record("network", condition);
+      return result;
+    },
+    location: async (op) => {
+      const result = await driver.location(op);
+      if (result.success)
+        recorder?.record("location", op);
+      return result;
+    }
+  });
+  function track(scheduler) {
+    const run = {
+      async stop() {
+        scheduler.stop();
+        const outcome = await scheduler.done;
+        runs.delete(run);
+        if (flap?.run === run)
+          flap = undefined;
+        return outcome;
+      },
+      done: scheduler.done,
+      status: () => scheduler.current()
+    };
+    runs.add(run);
+    return run;
+  }
+  async function stopFlap() {
+    const running = flap;
+    if (running === undefined)
+      return;
+    await running.run.stop();
+  }
+  async function applyNetwork(condition, options) {
+    await stopFlap();
+    networkDirty = true;
+    const opts = options?.relaunch === undefined ? undefined : { relaunch: options.relaunch };
+    const state = await call("network", () => driver.network(condition, opts));
+    currentNetwork = condition;
+    recorder?.record("network", condition);
+    emit({ area: "network", value: condition });
+    return state;
+  }
+  async function startFlapRun(options, netOptions) {
+    const upMs = durationMs(options.up, "flap up");
+    const downMs = durationMs(options.down, "flap down");
+    if (!(upMs > 0 && downMs > 0))
+      throw invalid2("flap needs up and down above 0");
+    const base = options.base === undefined ? ONLINE2 : network(options.base);
+    if (base.kind === "flap")
+      throw invalid2("flap base cannot itself be a flap");
+    await applyNetwork(base, netOptions);
+    const scheduler = startFlap(target(netOptions), {
+      upMs,
+      downMs,
+      base,
+      applyInitial: false,
+      ...options.jitterPct === undefined ? {} : { jitterPct: options.jitterPct },
+      ...options.seed === undefined ? {} : { seed: options.seed }
+    }, { ...ticker, ...deps.sink === undefined ? {} : { sink: deps.sink } });
+    const run = track(scheduler);
+    flap = { run, options };
+    currentNetwork = {
+      kind: "flap",
+      upMs,
+      downMs,
+      base,
+      ...options.jitterPct === undefined ? {} : { jitterPct: options.jitterPct }
+    };
+    emit({ area: "network", value: currentNetwork });
+    return run;
+  }
+  async function setNetwork(input, options) {
+    const condition = network(input);
+    if (condition.kind === "flap") {
+      await startFlapRun({
+        up: condition.upMs,
+        down: condition.downMs,
+        ...condition.jitterPct === undefined ? {} : { jitterPct: condition.jitterPct },
+        ...condition.base === undefined ? {} : { base: condition.base }
+      }, options);
+      return { online: true, condition, needsProxy: [] };
+    }
+    return applyNetwork(condition, options);
+  }
+  async function restoreNetwork(previous, previousFlap, options) {
+    if (previous.kind === "flap" && previousFlap !== undefined)
+      await startFlapRun(previousFlap, options);
+    else
+      await applyNetwork(previous, options);
+  }
+  async function resetNetwork() {
+    await stopFlap();
+    if (currentFaults.length > 0)
+      await setFaults([]);
+    const goal = baseline.network ?? ONLINE2;
+    await applyNetwork(goal);
+    networkDirty = false;
+    recorder?.settle("network", goal, goal.kind === "online");
+  }
+  async function setFaults(rules) {
+    networkDirty = true;
+    const result = await call("network faults", () => driver.networkFaults(rules));
+    currentFaults = rules;
+    recorder?.record("network", currentNetwork);
+    emit({ area: "faults", value: { kind: "faults", rules } });
+    return result;
+  }
+  const networkApi = {
+    set: setNetwork,
+    async during(condition, fn, options) {
+      const previous = currentNetwork;
+      const previousFlap = flap?.options;
+      await setNetwork(condition, options);
+      let result;
+      try {
+        result = await fn();
+      } catch (error) {
+        await restoreNetwork(previous, previousFlap, options).catch((restoreError) => log(`[warden-e2e] network.during: restoring the previous network failed: ${String(restoreError instanceof Error ? restoreError.message : restoreError)}`));
+        throw error;
+      }
+      await restoreNetwork(previous, previousFlap, options);
+      return result;
+    },
+    flap: (options) => startFlapRun(options),
+    fault: (rules) => setFaults("match" in rules ? [rules] : rules),
+    async status() {
+      return { condition: currentNetwork, faults: currentFaults, flapping: flap !== undefined };
+    },
+    reset: resetNetwork
+  };
+  async function applyLocation(op) {
+    locationDirty = true;
+    await call("location", () => driver.location(op));
+    recorder?.record("location", op);
+    emit({ area: "location", value: op });
+  }
+  const locationApi = {
+    async set(point) {
+      validatePoint(point);
+      await applyLocation({
+        kind: "point",
+        lat: point.lat,
+        lon: point.lon,
+        ...point.altM === undefined ? {} : { altM: point.altM }
+      });
+    },
+    async route(points, options = {}) {
+      const pace = {
+        ...options.speedMps === undefined ? {} : { speedMps: options.speedMps }
+      };
+      if ("gpx" in points) {
+        await applyLocation({ kind: "gpx", path: resolve3(points.gpx), ...pace });
+        return;
+      }
+      if (points.length === 0)
+        throw invalid2("a route needs at least one point");
+      for (const point of points)
+        validatePoint(point);
+      await applyLocation({
+        kind: "route",
+        points,
+        ...pace,
+        ...options.intervalS === undefined ? {} : { intervalS: options.intervalS },
+        ...options.loop === undefined ? {} : { loop: options.loop }
+      });
+    },
+    async scenario(name) {
+      if (!SCENARIOS.includes(name))
+        throw invalid2(`unknown scenario "${String(name)}" (use ${SCENARIOS.join(", ")})`);
+      await applyLocation({ kind: "scenario", name });
+    },
+    clear: () => applyLocation({ kind: "clear" })
+  };
+  async function applyClock(condition) {
+    const op = driver.clock;
+    clockDirty = true;
+    if (typeof op !== "function") {
+      throw toE2eError({ code: "E_UNSUPPORTED", message: "this driver has no clock condition", retryable: false }, "clock");
+    }
+    await call("clock", () => op.call(driver, condition));
+    currentClock = condition;
+    clockSetAt = ticker.now();
+    emit({ area: "clock", value: condition });
+  }
+  function clockFor(at, frozen) {
+    const iso = instant(at).toISOString();
+    return frozen === true ? { kind: "frozen", at: iso } : { kind: "fixed", at: iso };
+  }
+  function advanced(by) {
+    switch (currentClock.kind) {
+      case "real":
+        return { kind: "offset", ms: by };
+      case "offset":
+        return { kind: "offset", ms: currentClock.ms + by };
+      case "frozen":
+        return { kind: "frozen", at: new Date(Date.parse(currentClock.at) + by).toISOString() };
+      case "fixed": {
+        const now = Date.parse(currentClock.at) + (ticker.now() - clockSetAt);
+        return { kind: "fixed", at: new Date(now + by).toISOString() };
+      }
+    }
+  }
+  const clockApi = {
+    async set(at, options) {
+      await applyClock(clockFor(at, options?.frozen));
+    },
+    async advance(by) {
+      await applyClock(advanced(durationMs(by, "advance")));
+    },
+    async during(at, fn, options) {
+      const previous = currentClock;
+      await applyClock(clockFor(at, options?.frozen));
+      let result;
+      try {
+        result = await fn();
+      } catch (error) {
+        await applyClock(previous).catch((restoreError) => log(`[warden-e2e] clock.during: restoring the previous clock failed: ${String(restoreError instanceof Error ? restoreError.message : restoreError)}`));
+        throw error;
+      }
+      await applyClock(previous);
+      return result;
+    },
+    async reset() {
+      await applyClock(baseline.clock ?? REAL_CLOCK);
+      clockDirty = false;
+    },
+    status: () => currentClock
+  };
+  function settingOp(name) {
+    const op = driver[name];
+    if (typeof op !== "function") {
+      throw toE2eError({ code: "E_UNSUPPORTED", message: `this driver has no ${name} op`, retryable: false }, name);
+    }
+    return op.bind(driver);
+  }
+  const recordPermissions = (bundleId) => {
+    const value = {
+      grants: [...permissionStates].map(([permission, state]) => ({ bundleId, permission, state }))
+    };
+    recorder?.record("permission", value);
+    emit({ area: "permission", value });
+  };
+  async function applyPermissions(grants, options) {
+    permissionsDirty = true;
+    const op = settingOp("permissions");
+    const state = await call("permissions", () => op(grants, options ?? { bundleId: env.bundleId }));
+    for (const { permission, state: applied } of state.applied)
+      permissionStates.set(permission, applied);
+    permissionBundle = state.bundleId;
+    recordPermissions(state.bundleId);
+    return state;
+  }
+  const permissionsApi = {
+    set: applyPermissions,
+    async reset(options) {
+      const baselinePermissions = baseline.permissions ?? {};
+      const back = {};
+      for (const name of permissionStates.keys())
+        back[name] = baselinePermissions[name] ?? "unset";
+      if (Object.keys(back).length === 0)
+        return;
+      await applyPermissions(back, options ?? (permissionBundle ? { bundleId: permissionBundle } : undefined));
+      permissionsDirty = false;
+      permissionStates.clear();
+      recorder?.settle("permission", { grants: [] }, true);
+    }
+  };
+  function recordLocale() {
+    const empty = currentLocale.locale === undefined && currentLocale.timezone === undefined;
+    if (empty)
+      recorder?.settle("locale", currentLocale, true);
+    else
+      recorder?.record("locale", currentLocale);
+    emit({ area: "locale", value: currentLocale });
+  }
+  async function applyTimezone(tz) {
+    localeDirty = true;
+    const op = settingOp("timezone");
+    const previous = currentLocale.previousTimezone;
+    const state = await call("timezone", () => op(tz, previous === undefined ? undefined : { previous }));
+    const { timezone: _gone, ...rest } = currentLocale;
+    currentLocale = {
+      ...rest,
+      ...tz === null ? {} : { timezone: tz },
+      ...previous ?? state.previous ? { previousTimezone: previous ?? state.previous } : {}
+    };
+    recordLocale();
+    return state;
+  }
+  async function applyLocale(tag, options) {
+    localeDirty = true;
+    const op = settingOp("locale");
+    const state = await call("locale", () => op(tag, options ?? { bundleId: env.bundleId }));
+    const { locale: _gone, ...rest } = currentLocale;
+    currentLocale = {
+      ...rest,
+      ...tag === null ? {} : { locale: tag },
+      ...state.bundleId === undefined ? {} : { bundleId: state.bundleId }
+    };
+    recordLocale();
+    return state;
+  }
+  function checkedA11y(op) {
+    if (op === null)
+      return;
+    if (op.textSize !== undefined) {
+      const size = resolveTextSize(op.textSize);
+      if (!size.success)
+        throw invalid2(size.error);
+    }
+    if (Object.keys(op).length === 0)
+      throw invalid2("a11y needs at least one of textSize, boldText, contrast, reduceMotion");
+  }
+  async function applyA11y(op) {
+    checkedA11y(op);
+    a11yDirty = true;
+    const run = settingOp("a11y");
+    const state = await call("a11y", () => run(op));
+    const resolved = op?.textSize === undefined ? undefined : resolveTextSize(op.textSize);
+    currentA11y = op === null ? {} : {
+      ...currentA11y,
+      ...appliedA11y(op, state.applied),
+      ...resolved?.success ? { fontScale: resolved.data.scale } : {}
+    };
+    if (Object.keys(currentA11y).length === 0)
+      recorder?.settle("a11y", currentA11y, true);
+    else
+      recorder?.record("a11y", currentA11y);
+    emit({ area: "a11y", value: currentA11y });
+    return state;
+  }
+  async function applyBattery(op) {
+    batteryDirty = true;
+    const run = settingOp("battery");
+    const state = await call("battery", () => run(op));
+    const value = op === null ? {} : { ...op, cosmetic: state.cosmetic };
+    if (op === null)
+      recorder?.settle("battery", value, true);
+    else
+      recorder?.record("battery", value);
+    emit({ area: "battery", value });
+    return state;
+  }
+  async function startTimelineRun(steps) {
+    const converted = steps.map((step, index) => {
+      const atMs = durationMs(step.at, `timeline step ${index} at`);
+      const converted = { atMs };
+      if (step.network !== undefined) {
+        const condition = network(step.network);
+        if (condition.kind === "flap")
+          throw invalid2(`timeline step ${index}: use device.network.flap for a flap`);
+        converted.network = condition;
+      }
+      if (step.location !== undefined)
+        converted.location = locationOf(step.location);
+      return converted;
+    });
+    networkDirty = true;
+    locationDirty = true;
+    const scheduler = startTimeline(target(), converted, {
+      ...ticker,
+      ...deps.sink === undefined ? {} : { sink: deps.sink }
+    });
+    const status = scheduler.current();
+    if (status.state === "failed")
+      throw invalid2(status.error);
+    const run = track(scheduler);
+    const last = converted.at(-1);
+    if (last?.network !== undefined)
+      currentNetwork = last.network;
+    return run;
+  }
+  async function stopRuns() {
+    const failures = [];
+    for (const run of [...runs]) {
+      const outcome = await run.stop();
+      if (outcome.stopped === "failed")
+        failures.push(outcome.error);
+    }
+    if (failures.length > 0) {
+      throw new E2eError2("ACTION_FAILED", `a network flap or timeline stopped on its own after failing: ${failures[0]}`);
+    }
+  }
+  const declared = baseline.network !== undefined || baseline.location !== undefined || baseline.clock !== undefined || baseline.permissions !== undefined || baseline.locale !== undefined || baseline.timezone !== undefined || baseline.a11y !== undefined;
+  const internals = {
+    declared,
+    dirty: () => networkDirty || locationDirty || clockDirty || permissionsDirty || localeDirty || a11yDirty || batteryDirty || runs.size > 0,
+    wantsInject: () => baseline.network !== undefined || baseline.clock !== undefined || currentNetwork.kind !== "online" || currentClock.kind !== "real",
+    async applyBaseline() {
+      if (baseline.permissions !== undefined) {
+        for (const [name, state] of Object.entries(baseline.permissions))
+          permissionStates.set(name, state);
+        await applyPermissions(baseline.permissions);
+      }
+      if (baseline.timezone !== undefined)
+        await applyTimezone(baseline.timezone);
+      if (baseline.locale !== undefined)
+        await applyLocale(baseline.locale);
+      if (baseline.a11y !== undefined)
+        await applyA11y(a11yOpOf(baseline.a11y));
+      if (baseline.clock !== undefined)
+        await applyClock(baseline.clock);
+      if (baseline.location !== undefined)
+        await applyLocation(baseline.location);
+      if (baseline.network !== undefined)
+        await applyNetwork(baseline.network, { relaunch: true });
+      networkDirty = false;
+      locationDirty = false;
+      clockDirty = false;
+      permissionsDirty = false;
+      localeDirty = false;
+      a11yDirty = false;
+      batteryDirty = false;
+    },
+    async teardown() {
+      const errors = [];
+      const attempt = async (run) => {
+        try {
+          await run();
+        } catch (error) {
+          errors.push(error);
+        }
+      };
+      await attempt(stopRuns);
+      if (networkDirty)
+        await attempt(resetNetwork);
+      if (locationDirty) {
+        await attempt(async () => {
+          const goal = baseline.location ?? { kind: "clear" };
+          await applyLocation(goal);
+          locationDirty = false;
+          recorder?.settle("location", goal, goal.kind === "clear");
+        });
+      }
+      if (clockDirty)
+        await attempt(clockApi.reset);
+      if (permissionsDirty)
+        await attempt(() => permissionsApi.reset());
+      if (localeDirty) {
+        await attempt(async () => {
+          await applyTimezone(baseline.timezone ?? null);
+          await applyLocale(baseline.locale ?? null);
+          localeDirty = false;
+        });
+      }
+      if (a11yDirty) {
+        await attempt(async () => {
+          await applyA11y(null);
+          if (baseline.a11y !== undefined)
+            await applyA11y(a11yOpOf(baseline.a11y));
+          a11yDirty = false;
+        });
+      }
+      if (batteryDirty) {
+        await attempt(async () => {
+          await applyBattery(null);
+          batteryDirty = false;
+        });
+      }
+      if (errors.length > 0)
+        throw errors[0];
+    }
+  };
+  return {
+    network: networkApi,
+    location: locationApi,
+    clock: clockApi,
+    permissions: permissionsApi,
+    timezone: applyTimezone,
+    locale: applyLocale,
+    a11y: applyA11y,
+    battery: applyBattery,
+    memoryWarning: async (options) => {
+      const op = settingOp("memoryWarning");
+      await call("memoryWarning", () => op(options ?? { bundleId: env.bundleId }));
+    },
+    push: async (payload, options) => {
+      const op = settingOp("push");
+      await call("push", () => op(payload, options ?? { bundleId: env.bundleId }));
+    },
+    timeline: startTimelineRun,
+    internals
+  };
+}
+
 // ../../packages/e2e/src/perf/device-perf.ts
-import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync } from "fs";
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync } from "fs";
 import { join as join2 } from "path";
 
 // ../../packages/e2e/src/perf/budgets.ts
@@ -5677,7 +6987,7 @@ function saveReport(deps, result, report, sessionId) {
   if (attempt === undefined)
     return sessionReport;
   const out = join2(attempt, PERF_DIR);
-  mkdirSync3(out, { recursive: true });
+  mkdirSync4(out, { recursive: true });
   const sessionDir = typeof result.dir === "string" ? result.dir : undefined;
   const write = (name, from, fallback) => {
     if (from !== undefined && existsSync3(from))
@@ -5795,9 +7105,9 @@ function specIdOf(file, specsDir) {
 }
 
 // ../../packages/e2e/src/devtools/native-log.ts
-import { copyFileSync as copyFileSync2, mkdirSync as mkdirSync4, readdirSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { copyFileSync as copyFileSync2, mkdirSync as mkdirSync5, readdirSync, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname4, join as join4 } from "path";
 var NATIVE_LOG = "native.log";
 var DEFAULT_TIMEOUT_MS5 = 1e4;
 var SLACK_S = 5;
@@ -5812,11 +7122,11 @@ function realNativeFs() {
       }
     },
     copy: (from, to) => {
-      mkdirSync4(dirname3(to), { recursive: true });
+      mkdirSync5(dirname4(to), { recursive: true });
       copyFileSync2(from, to);
     },
     write: (path, text) => {
-      mkdirSync4(dirname3(path), { recursive: true });
+      mkdirSync5(dirname4(path), { recursive: true });
       writeFileSync2(path, text);
     }
   };
@@ -6005,7 +7315,8 @@ function registrationDefaults(env = process.env) {
     timeoutMs: parsed?.timeoutMs ?? DEFAULT_TIMEOUT_MS4,
     actionTimeoutMs: parsed?.actionTimeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS,
     assertionTimeoutMs: parsed?.assertionTimeoutMs ?? DEFAULT_ASSERTION_TIMEOUT_MS,
-    platform: parsed?.platform
+    platform: parsed?.platform,
+    deviceKind: parsed?.deviceKind
   };
 }
 var ONLY_KEY = Symbol.for("@delacour/warden-e2e/only");
@@ -6018,6 +7329,6 @@ function onlyWasSeen() {
 
 // ../../packages/e2e/src/version.ts
 var WORKSPACE_VERSION = "0.0.0-workspace";
-var WARDEN_E2E_VERSION2 = "0.6.0";
+var WARDEN_E2E_VERSION2 = "0.7.0";
 
-export { E2eError2, noteSpanDetail, addSpanDetail, canObserve, canDetectAlerts, settleDetailOf, DEFAULT_SETTLE_QUIET_MS, DEFAULT_SETTLE_TIMEOUT_MS, settleByHash, snapshotHash, ok, err, swipeVector, screenRect, fieldValue, PINCH_MS, ROTATE_MS, PATH_MS, centreOf, pinchRadius, rotateRadius, requireGesture, assertScale, assertDegrees, isInteractiveRole, resolveRole, normalizeText, matchesText, indexSnapshot, testIdQuery, textQuery, roleQuery, selectorExpression, renderSnapshot, renderHeader, resolve, locateByTestIdViaReact, isLocator, Locator, pickOne, textOf, scrollUntilVisible, bunExec, execError, driverError, driverErr, logEventSchema, fatalEventSchema, responseSchema, mapWireError, encodeRequest, bunSpawn, stdioTransport, spawnSimd, connectSimd, isHidLost, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, parseBudgets, createDevicePerf, perfStartFor, spawnWarden, hash6, attemptDir, screenshotPath, specIdOf, realNativeLogDeps, captureNativeLog, callerFile, BUN_TIMEOUT_MARGIN_MS2, ownHook, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION2 };
+export { E2eError2, 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 };