@delacour/warden-e2e 0.0.0-stage → 0.1.1

package/chunk-qtkmfjbq.mjs

@@ -0,0 +1,4585 @@
+// @bun
+// ../../packages/e2e/src/errors.ts
+class E2eError extends Error {
+  code;
+  screen;
+  matches;
+  constructor(code, message, screen, matches) {
+    super(message);
+    this.name = "E2eError";
+    this.code = code;
+    if (screen !== undefined)
+      this.screen = screen;
+    if (matches !== undefined)
+      this.matches = matches;
+  }
+  static from(shape) {
+    return shape instanceof E2eError ? shape : new E2eError(shape.code, shape.message, shape.screen, shape.matches);
+  }
+}
+function e2eErr(error) {
+  return { success: false, error: E2eError.from(error) };
+}
+
+// ../../packages/e2e/src/env.ts
+import { z } from "zod";
+var ENV_NAMES = {
+  udid: "WARDEN_UDID",
+  deviceName: "WARDEN_DEVICE_NAME",
+  platform: "WARDEN_PLATFORM",
+  bundleId: "WARDEN_BUNDLE_ID",
+  appPath: "WARDEN_APP_PATH",
+  metroUrl: "WARDEN_METRO_URL",
+  launchArgs: "WARDEN_LAUNCH_ARGS",
+  out: "WARDEN_E2E_OUT",
+  timeout: "WARDEN_E2E_TIMEOUT",
+  actionTimeout: "WARDEN_E2E_ACTION_TIMEOUT",
+  assertionTimeout: "WARDEN_E2E_ASSERTION_TIMEOUT",
+  flowsDir: "WARDEN_E2E_FLOWS_DIR",
+  helperDir: "WARDEN_HELPER_DIR",
+  simd: "WARDEN_SIMD",
+  simdSocket: "WARDEN_SIMD_SOCKET",
+  headless: "WARDEN_HEADLESS",
+  logTimestamps: "WARDEN_LOG_TIMESTAMPS",
+  worker: "WARDEN_WORKER",
+  version: "WARDEN_VERSION"
+};
+var DEFAULT_TIMEOUT_MS = 120000;
+var DEFAULT_ACTION_TIMEOUT_MS = 30000;
+var DEFAULT_ASSERTION_TIMEOUT_MS = 5000;
+var toggle = z.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
+var millis = z.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z.number().int().positive());
+var launchArgs = z.string().transform((raw, ctx) => {
+  try {
+    const parsed = z.array(z.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 z.NEVER;
+});
+var REQUIRED = "required when WARDEN_UDID is set";
+var schema = z.object({
+  udid: z.string().min(1),
+  deviceName: z.string().optional(),
+  platform: z.enum(["ios", "android"]).default("ios"),
+  bundleId: z.string({ error: REQUIRED }).min(1, REQUIRED),
+  appPath: z.string().optional(),
+  metroUrl: z.string().optional(),
+  launchArgs: launchArgs.default([]),
+  out: z.string().optional(),
+  timeout: millis.default(DEFAULT_TIMEOUT_MS),
+  actionTimeout: millis.default(DEFAULT_ACTION_TIMEOUT_MS),
+  assertionTimeout: millis.default(DEFAULT_ASSERTION_TIMEOUT_MS),
+  flowsDir: z.string().optional(),
+  helperDir: z.string().optional(),
+  simd: z.string().optional(),
+  simdSocket: z.string().optional(),
+  headless: toggle.default(false),
+  logTimestamps: toggle.default(false),
+  worker: z.string().optional(),
+  version: z.string().optional()
+});
+function defined(values) {
+  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
+}
+function toEnv(v, now) {
+  return {
+    udid: v.udid,
+    platform: v.platform,
+    bundleId: v.bundleId,
+    launchArgs: v.launchArgs,
+    out: v.out ?? `.warden-e2e/${now().toISOString()}`,
+    timeoutMs: v.timeout,
+    actionTimeoutMs: v.actionTimeout,
+    assertionTimeoutMs: v.assertionTimeout,
+    headless: v.headless,
+    logTimestamps: v.logTimestamps,
+    ...defined({
+      deviceName: v.deviceName,
+      appPath: v.appPath,
+      metroUrl: v.metroUrl,
+      flowsDir: v.flowsDir,
+      helperDir: v.helperDir,
+      simd: v.simd,
+      simdSocket: v.simdSocket,
+      worker: v.worker,
+      wardenVersion: v.version
+    })
+  };
+}
+var isEnvKey = (key) => typeof key === "string" && (key in ENV_NAMES);
+function readEnv(env, opts = {}) {
+  const udid = env[ENV_NAMES.udid];
+  if (udid === undefined || udid === "")
+    return { success: true, data: undefined };
+  const raw = {};
+  for (const [key, name] of Object.entries(ENV_NAMES)) {
+    const value = env[name];
+    raw[key] = value === undefined || value === "" ? undefined : value;
+  }
+  const parsed = schema.safeParse(raw);
+  if (!parsed.success) {
+    const lines = parsed.error.issues.map((issue) => {
+      const key = issue.path[0];
+      return `${isEnvKey(key) ? ENV_NAMES[key] : String(key)}: ${issue.message}`;
+    });
+    return { success: false, error: lines.join(`
+`) };
+  }
+  return { success: true, data: toEnv(parsed.data, opts.now ?? (() => new Date)) };
+}
+
+// ../../packages/e2e/src/session.ts
+import { mkdirSync as mkdirSync2, writeSync } from "fs";
+import { resolve } from "path";
+
+// ../../packages/e2e/src/devtools/devtools.types.ts
+function devtoolsErr(code, message) {
+  return { success: false, error: { code, message } };
+}
+
+// ../../packages/e2e/src/devtools/facet.ts
+import { join } from "path";
+
+// ../../packages/types/src/result.ts
+function ok(data) {
+  return { success: true, data };
+}
+function err(error) {
+  return {
+    success: false,
+    error: error instanceof Error ? error.message : String(error)
+  };
+}
+
+// ../../packages/e2e/src/devtools/console.ts
+import { z as z3 } from "zod";
+
+// ../../packages/e2e/src/devtools/cdp.ts
+import { z as z2 } from "zod";
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+var envelopeSchema = z2.looseObject({
+  id: z2.number().optional(),
+  result: z2.unknown().optional(),
+  error: z2.looseObject({ message: z2.string().optional() }).optional(),
+  method: z2.string().optional(),
+  params: z2.unknown().optional()
+});
+var exceptionDetailsSchema = z2.looseObject({
+  text: z2.string().optional(),
+  lineNumber: z2.number().optional(),
+  columnNumber: z2.number().optional(),
+  url: z2.string().optional(),
+  exception: z2.looseObject({
+    type: z2.string().optional(),
+    subtype: z2.string().optional(),
+    className: z2.string().optional(),
+    description: z2.string().optional(),
+    value: z2.unknown().optional()
+  }).optional()
+});
+var bindingPayloadSchema = z2.looseObject({ requestId: z2.string() });
+var bindingCalledSchema = z2.looseObject({ name: z2.string().optional(), payload: z2.string() });
+var evaluateReplySchema = z2.looseObject({
+  result: z2.looseObject({ type: z2.string().optional(), value: z2.unknown().optional() }).optional(),
+  exceptionDetails: exceptionDetailsSchema.optional()
+});
+function readEvaluateReply(reply) {
+  const parsed = evaluateReplySchema.safeParse(reply);
+  if (!parsed.success)
+    return { value: undefined, type: undefined, exceptionDetails: undefined };
+  return {
+    value: parsed.data.result?.value,
+    type: parsed.data.result?.type,
+    exceptionDetails: parsed.data.exceptionDetails
+  };
+}
+function describeException(details) {
+  const thrown = details.exception;
+  if (thrown?.description)
+    return thrown.description;
+  if (thrown?.value !== undefined)
+    return String(thrown.value);
+  return details.text ?? "JS exception";
+}
+function textOf(data) {
+  if (typeof data === "string")
+    return data;
+  if (data instanceof ArrayBuffer)
+    return new TextDecoder().decode(data);
+  if (ArrayBuffer.isView(data))
+    return new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  return;
+}
+function inspectorOrigin(wsUrl) {
+  if (!URL.canParse(wsUrl))
+    return;
+  const url = new URL(wsUrl);
+  const port = url.port || (url.protocol === "wss:" ? "443" : "80");
+  return `http://127.0.0.1:${port}`;
+}
+async function openCdp(wsUrl, options = {}) {
+  const Impl = options.WebSocket ?? WebSocket;
+  const defaultTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  let ws;
+  try {
+    const origin = inspectorOrigin(wsUrl);
+    ws = origin ? new Impl(wsUrl, { headers: { Origin: origin } }) : new Impl(wsUrl);
+  } catch (error) {
+    return devtoolsErr("devtools_unavailable", `bad inspector url ${wsUrl}: ${String(error)}`);
+  }
+  const opened = await new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      resolve(devtoolsErr("devtools_unavailable", `inspector socket ${wsUrl} did not open within ${defaultTimeout} ms`));
+      ws.close();
+    }, defaultTimeout);
+    ws.addEventListener("open", () => {
+      clearTimeout(timer);
+      resolve(ok(true));
+    });
+    const failed = () => {
+      clearTimeout(timer);
+      resolve(devtoolsErr("devtools_unavailable", `could not connect to inspector socket ${wsUrl}`));
+    };
+    ws.addEventListener("error", failed);
+    ws.addEventListener("close", failed);
+  });
+  if (!opened.success)
+    return opened;
+  let nextId = 1;
+  let intentional = false;
+  let closed = false;
+  let bindingAvailable;
+  const pending = new Map;
+  const bindings = new Map;
+  const listeners = new Map;
+  const closeHandlers = new Set;
+  const anyHandlers = new Set;
+  const send = (method, params = {}, opts = {}) => {
+    if (closed || ws.readyState !== ws.OPEN)
+      return Promise.resolve(devtoolsErr("cdp_closed", `CDP socket is closed (${method})`));
+    const id = nextId++;
+    const timeoutMs = opts.timeoutMs ?? defaultTimeout;
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        resolve(devtoolsErr("cdp_timeout", `CDP ${method} (id ${id}) got no reply within ${timeoutMs} ms`));
+      }, timeoutMs);
+      pending.set(id, { resolve, timer });
+      ws.send(JSON.stringify({ id, method, params }));
+    });
+  };
+  const dispatch = (method, params) => {
+    if (method === "Runtime.bindingCalled") {
+      const call = bindingCalledSchema.safeParse(params);
+      if (call.success) {
+        let payload;
+        try {
+          payload = JSON.parse(call.data.payload);
+        } catch {
+          payload = undefined;
+        }
+        const tagged = bindingPayloadSchema.safeParse(payload);
+        if (tagged.success)
+          bindings.get(tagged.data.requestId)?.settle(ok(payload));
+      }
+    }
+    for (const handler of [...anyHandlers])
+      handler(method, params);
+    for (const handler of [...listeners.get(method) ?? []])
+      handler(params);
+  };
+  ws.addEventListener("message", (event) => {
+    const text = textOf(event.data);
+    if (text === undefined)
+      return;
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      return;
+    }
+    const message = envelopeSchema.safeParse(json);
+    if (!message.success)
+      return;
+    const { id, error, result, method, params } = message.data;
+    if (id !== undefined) {
+      const request = pending.get(id);
+      if (!request)
+        return;
+      pending.delete(id);
+      clearTimeout(request.timer);
+      request.resolve(error ? devtoolsErr("cdp_protocol", error.message ?? JSON.stringify(error)) : ok(result ?? {}));
+      return;
+    }
+    if (method)
+      dispatch(method, params);
+  });
+  ws.addEventListener("close", () => {
+    if (closed)
+      return;
+    closed = true;
+    for (const [, request] of pending) {
+      clearTimeout(request.timer);
+      request.resolve(devtoolsErr("cdp_closed", "CDP connection closed"));
+    }
+    pending.clear();
+    for (const binding of [...bindings.values()])
+      binding.settle(devtoolsErr("cdp_closed", "CDP connection closed"));
+    if (!intentional)
+      for (const handler of [...closeHandlers])
+        handler();
+  });
+  const subscribe = (set, handler) => {
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  };
+  const client = {
+    send,
+    on(event, handler) {
+      let set = listeners.get(event);
+      if (!set) {
+        set = new Set;
+        listeners.set(event, set);
+      }
+      return subscribe(set, handler);
+    },
+    onClose: (handler) => subscribe(closeHandlers, handler),
+    onAny: (handler) => subscribe(anyHandlers, handler),
+    async addBinding(name) {
+      const added = await send("Runtime.addBinding", { name });
+      if (!added.success)
+        return added;
+      const probe = await send("Runtime.evaluate", { expression: `typeof ${name}`, returnByValue: true });
+      const value = probe.success ? readEvaluateReply(probe.data).value : undefined;
+      bindingAvailable = value !== "undefined";
+      return ok({ available: bindingAvailable });
+    },
+    evaluateWithBinding(script, requestId, timeoutMs = defaultTimeout) {
+      if (bindingAvailable === false) {
+        return Promise.resolve(devtoolsErr("binding_unavailable", "this JS runtime acknowledges Runtime.addBinding but never installs the binding (legacy Hermes, React Native <= 0.72)"));
+      }
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          settle(devtoolsErr("cdp_timeout", `no binding callback for requestId ${requestId} within ${timeoutMs} ms`));
+        }, timeoutMs);
+        const settle = (result) => {
+          clearTimeout(timer);
+          bindings.delete(requestId);
+          resolve(result);
+        };
+        bindings.set(requestId, { settle });
+        send("Runtime.evaluate", { expression: script, returnByValue: false, awaitPromise: false }, { timeoutMs }).then((reply) => {
+          if (!reply.success)
+            return settle(reply);
+          const { exceptionDetails } = readEvaluateReply(reply.data);
+          if (exceptionDetails)
+            settle(devtoolsErr("eval_failed", describeException(exceptionDetails)));
+        });
+      });
+    },
+    get bindingAvailable() {
+      return bindingAvailable;
+    },
+    close() {
+      intentional = true;
+      if (!closed)
+        ws.close();
+    }
+  };
+  return ok(client);
+}
+
+// ../../packages/e2e/src/devtools/jsonl.ts
+import { appendFile, mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+var encode = (rows) => rows.map((row) => `${JSON.stringify(row)}
+`).join("");
+async function writeJsonl(path, rows) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, encode(rows));
+}
+
+// ../../packages/e2e/src/devtools/console.ts
+var DEFAULT_RING = 500;
+var MAX_FUNCTION_TEXT = 60;
+var propertyPreviewSchema = z3.looseObject({
+  name: z3.string(),
+  type: z3.string(),
+  subtype: z3.string().optional(),
+  value: z3.string().optional()
+});
+var objectPreviewSchema = z3.looseObject({
+  subtype: z3.string().optional(),
+  overflow: z3.boolean().optional(),
+  properties: z3.array(propertyPreviewSchema).optional()
+});
+var remoteObjectSchema = z3.looseObject({
+  type: z3.string(),
+  subtype: z3.string().optional(),
+  className: z3.string().optional(),
+  value: z3.unknown().optional(),
+  unserializableValue: z3.string().optional(),
+  description: z3.string().optional(),
+  preview: objectPreviewSchema.optional()
+});
+var stackTraceSchema = z3.looseObject({
+  callFrames: z3.array(z3.looseObject({
+    url: z3.string().optional(),
+    lineNumber: z3.number().optional(),
+    columnNumber: z3.number().optional()
+  }))
+});
+var consoleCalledSchema = z3.looseObject({
+  type: z3.string(),
+  args: z3.array(remoteObjectSchema).default([]),
+  timestamp: z3.number().optional(),
+  stackTrace: stackTraceSchema.optional()
+});
+var exceptionThrownSchema = z3.looseObject({
+  timestamp: z3.number().optional(),
+  exceptionDetails: exceptionDetailsSchema
+});
+var LEVELS = {
+  log: "log",
+  info: "info",
+  debug: "debug",
+  warning: "warn",
+  error: "error",
+  assert: "error"
+};
+function formatProperty(property) {
+  const value = property.value ?? property.type;
+  return property.type === "string" ? JSON.stringify(value) : value;
+}
+function formatPreview(object) {
+  const preview = object.preview;
+  if (!preview?.properties)
+    return;
+  const more = preview.overflow ? ", \u2026" : "";
+  if (preview.subtype === "array")
+    return `[${preview.properties.map(formatProperty).join(", ")}${more}]`;
+  const body = preview.properties.map((p) => `${p.name}: ${formatProperty(p)}`).join(", ");
+  const name = object.className && object.className !== "Object" ? `${object.className} ` : "";
+  return `${name}{${body}${more}}`;
+}
+function formatValue(object) {
+  switch (object.type) {
+    case "string":
+      return String(object.value ?? "");
+    case "undefined":
+      return "undefined";
+    case "number":
+    case "boolean":
+    case "bigint":
+      return object.unserializableValue ?? object.description ?? String(object.value);
+    case "function": {
+      const first = (object.description ?? "function").split(`
+`)[0] ?? "function";
+      return first.length > MAX_FUNCTION_TEXT ? `${first.slice(0, MAX_FUNCTION_TEXT)}\u2026` : first;
+    }
+    case "object": {
+      if (object.subtype === "null")
+        return "null";
+      if (object.value !== undefined)
+        return JSON.stringify(object.value);
+      if (object.subtype === "error")
+        return object.description ?? "Error";
+      return formatPreview(object) ?? object.description ?? object.className ?? "Object";
+    }
+    default:
+      return object.description ?? `[${object.type}]`;
+  }
+}
+function applyFormat(format, rest) {
+  let used = 0;
+  const text = format.replace(/%([sdifoOjc%])/g, (whole, spec) => {
+    if (spec === "%")
+      return "%";
+    const arg = rest[used];
+    if (arg === undefined)
+      return whole;
+    used++;
+    if (spec === "c")
+      return "";
+    if (spec === "d" || spec === "i" || spec === "f") {
+      const n = Number(arg.value ?? arg.description);
+      return Number.isNaN(n) ? "NaN" : String(spec === "f" ? n : Math.trunc(n));
+    }
+    return formatValue(arg);
+  });
+  return { text, used };
+}
+function formatConsoleArgs(args) {
+  const rendered = args.map(formatValue);
+  const [first, ...rest] = args;
+  if (first?.type !== "string" || !String(first.value).includes("%"))
+    return { text: rendered.join(" "), args: rendered };
+  const { text, used } = applyFormat(String(first.value), rest);
+  return { text: [text, ...rendered.slice(1 + used)].join(" "), args: rendered };
+}
+function sourceOf(url, line, col) {
+  if (!url)
+    return;
+  return { url, line: (line ?? 0) + 1, col: (col ?? 0) + 1 };
+}
+var lineKey = (ts, text) => `${ts}\x00${text}`;
+function createConsoleCapture(options = {}) {
+  const ring = options.ring ?? DEFAULT_RING;
+  const now = options.now ?? Date.now;
+  let buffer = [];
+  const seen = new Map;
+  let epochConnection = -1;
+  let epochCounts = new Map;
+  const remember = (key, count) => {
+    seen.set(key, count);
+    if (seen.size > ring * 4) {
+      const oldest = seen.keys().next();
+      if (!oldest.done)
+        seen.delete(oldest.value);
+    }
+  };
+  const isNew = (event, line) => {
+    const key = lineKey(line.ts, line.text);
+    if (!event.replay) {
+      remember(key, (seen.get(key) ?? 0) + 1);
+      return true;
+    }
+    if (event.connection !== epochConnection) {
+      epochConnection = event.connection;
+      epochCounts = new Map;
+    }
+    const inBurst = (epochCounts.get(key) ?? 0) + 1;
+    epochCounts.set(key, inBurst);
+    if (inBurst <= (seen.get(key) ?? 0))
+      return false;
+    remember(key, inBurst);
+    return true;
+  };
+  const record = (line) => {
+    buffer.push(line);
+    if (buffer.length > ring)
+      buffer = buffer.slice(buffer.length - ring);
+    options.sink?.(line);
+  };
+  const fromConsole = (params) => {
+    const parsed = consoleCalledSchema.safeParse(params);
+    if (!parsed.success)
+      return;
+    const { type, args, timestamp, stackTrace } = parsed.data;
+    const formatted = formatConsoleArgs(args);
+    const frame = stackTrace?.callFrames[0];
+    const source = sourceOf(frame?.url, frame?.lineNumber, frame?.columnNumber);
+    return {
+      ts: timestamp ?? now(),
+      level: LEVELS[type] ?? "log",
+      kind: "console",
+      text: formatted.text,
+      args: formatted.args,
+      ...source ? { source } : {}
+    };
+  };
+  const fromException = (params) => {
+    const parsed = exceptionThrownSchema.safeParse(params);
+    if (!parsed.success)
+      return;
+    const { exceptionDetails: details, timestamp } = parsed.data;
+    const source = sourceOf(details.url, details.lineNumber, details.columnNumber);
+    return {
+      ts: timestamp ?? now(),
+      level: "error",
+      kind: "exception",
+      text: describeException(details),
+      ...source ? { source } : {}
+    };
+  };
+  return {
+    handle(event) {
+      let line;
+      if (event.method === "Runtime.consoleAPICalled")
+        line = fromConsole(event.params);
+      else if (event.method === "Runtime.exceptionThrown")
+        line = fromException(event.params);
+      if (line && isNew(event, line))
+        record(line);
+    },
+    lines: () => [...buffer],
+    clear() {
+      buffer = [];
+    },
+    mark(label) {
+      record({ ts: now(), level: "info", kind: "note", text: label });
+    },
+    writeJsonl: (path) => writeJsonl(path, buffer)
+  };
+}
+
+// ../../packages/e2e/src/devtools/network.ts
+import { z as z4 } from "zod";
+
+// ../../packages/e2e/src/devtools/network.script.ts
+var NETWORK_SCRIPT = `function (cfg, g) {
+  if (g.__warden_net_patched) return "already";
+  if (typeof g.fetch !== "function") return "no fetch";
+  g.__warden_net_patched = true;
+  var original = g.fetch;
+  var log = [];
+  var maxBody = cfg.maxBody || 65536;
+  var textual = /json|text|xml|javascript|x-www-form-urlencoded|graphql/i;
+
+  function skipped(url) {
+    for (var i = 0; i < cfg.skipPrefixes.length; i++) {
+      var prefix = cfg.skipPrefixes[i];
+      if (url.indexOf(prefix) === 0 && "/?#".indexOf(url.charAt(prefix.length) || "/") !== -1) return true;
+    }
+    return false;
+  }
+
+  function headersToObject(h) {
+    var out = {};
+    if (!h) return out;
+    if (Array.isArray(h)) {
+      for (var i = 0; i < h.length; i++) out[String(h[i][0]).toLowerCase()] = String(h[i][1]);
+    } else if (typeof h.forEach === "function") {
+      h.forEach(function (value, key) { out[String(key).toLowerCase()] = String(value); });
+    } else {
+      for (var k in h) if (Object.prototype.hasOwnProperty.call(h, k)) out[k.toLowerCase()] = String(h[k]);
+    }
+    return out;
+  }
+
+  function requestBodyText(body) {
+    if (typeof body === "string") return body.length > maxBody ? body.slice(0, maxBody) : body;
+    if (body && typeof body.toString === "function" && body.constructor && body.constructor.name === "URLSearchParams") {
+      return body.toString();
+    }
+    return undefined;
+  }
+
+  function push(entry) {
+    log.push(entry);
+    if (log.length > cfg.ring) log.shift();
+  }
+
+  g.__warden_net_drain = function () {
+    var out = log;
+    log = [];
+    return JSON.stringify(out);
+  };
+
+  g.fetch = function (input, init) {
+    var self = this;
+    var args = arguments;
+    var url = typeof input === "string" ? input : (input && input.url) || String(input);
+    if (skipped(url)) return original.apply(self, args);
+
+    var started = Date.now();
+    var entry = {
+      ts: started,
+      method: String((init && init.method) || (input && input.method) || "GET").toUpperCase(),
+      url: url,
+      status: 0,
+      durationMs: 0,
+      requestHeaders: headersToObject((init && init.headers) || (input && input.headers)),
+      responseHeaders: {}
+    };
+    if (cfg.includeBodies && init && init.body !== undefined && init.body !== null) {
+      var sent = requestBodyText(init.body);
+      if (sent !== undefined) entry.requestBody = sent;
+    }
+
+    return original.apply(self, args).then(function (res) {
+      entry.status = res.status;
+      entry.durationMs = Date.now() - started;
+      entry.responseHeaders = headersToObject(res.headers);
+      var type = entry.responseHeaders["content-type"] || "";
+      if (!cfg.includeBodies || !textual.test(type)) {
+        push(entry);
+        return res;
+      }
+      try {
+        res.clone().text().then(function (text) {
+          if (text.length > maxBody) {
+            entry.responseBody = text.slice(0, maxBody);
+            entry.responseBodyTruncated = true;
+          } else {
+            entry.responseBody = text;
+          }
+          push(entry);
+        }, function () { push(entry); });
+      } catch (e) {
+        push(entry);
+      }
+      return res;
+    }, function (error) {
+      entry.durationMs = Date.now() - started;
+      entry.error = error && error.message ? error.message : String(error);
+      push(entry);
+      throw error;
+    });
+  };
+  return "patched";
+}`;
+function networkInstallExpression(config) {
+  const global = `(typeof globalThis !== "undefined" ? globalThis : (0, eval)("this"))`;
+  return `(${NETWORK_SCRIPT})(${JSON.stringify(config)}, ${global})`;
+}
+var NETWORK_DRAIN_EXPRESSION = `typeof __warden_net_drain === "function" ? __warden_net_drain() : null`;
+
+// ../../packages/e2e/src/devtools/network.ts
+var DEFAULT_RING2 = 2000;
+var DEFAULT_POLL_MS = 500;
+var LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "10.0.2.2"];
+function metroSkipPrefixes(metroUrl) {
+  let url;
+  try {
+    url = new URL(metroUrl);
+  } catch {
+    return [];
+  }
+  const port = url.port ? `:${url.port}` : "";
+  const prefixes = [url.origin, ...LOOPBACK_HOSTS.map((host) => `${url.protocol}//${host}${port}`)];
+  return [...new Set(prefixes)];
+}
+var pageEntrySchema = z4.looseObject({
+  ts: z4.number(),
+  method: z4.string(),
+  url: z4.string(),
+  status: z4.number(),
+  durationMs: z4.number(),
+  requestHeaders: z4.record(z4.string(), z4.string()),
+  responseHeaders: z4.record(z4.string(), z4.string()),
+  requestBody: z4.string().optional(),
+  responseBody: z4.string().optional(),
+  responseBodyTruncated: z4.boolean().optional(),
+  error: z4.string().optional()
+});
+var timerSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function attachNetwork(session, options = {}) {
+  const ring = options.ring ?? DEFAULT_RING2;
+  const sleep = options.sleep ?? timerSleep;
+  const pollMs = options.pollMs ?? DEFAULT_POLL_MS;
+  const installExpression = networkInstallExpression({
+    ring,
+    includeBodies: options.includeBodies ?? false,
+    skipPrefixes: options.metroUrl ? metroSkipPrefixes(options.metroUrl) : []
+  });
+  let buffer = [];
+  let nextId = 1;
+  let stopped = false;
+  let queue = Promise.resolve();
+  const serial = (task) => {
+    const run = queue.then(task, task);
+    queue = run.catch(() => {
+      return;
+    });
+    return run;
+  };
+  const install = async () => {
+    const installed = await session.evaluate(installExpression);
+    if (installed.success)
+      return ok(true);
+    return { success: false, error: { code: installed.error.code ?? "eval_failed", message: installed.error.message } };
+  };
+  const take = (text) => {
+    let rows;
+    try {
+      rows = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!Array.isArray(rows))
+      return;
+    for (const row of rows) {
+      const parsed = pageEntrySchema.safeParse(row);
+      if (!parsed.success)
+        continue;
+      const entry = { ...parsed.data, id: nextId++ };
+      buffer.push(entry);
+      options.sink?.(entry);
+    }
+    if (buffer.length > ring)
+      buffer = buffer.slice(buffer.length - ring);
+  };
+  const drain = async () => {
+    const drained = await session.evaluate(NETWORK_DRAIN_EXPRESSION);
+    if (!drained.success)
+      return;
+    if (typeof drained.data === "string")
+      take(drained.data);
+    else if (drained.data === null)
+      await install();
+  };
+  const first = await install();
+  if (!first.success)
+    return first;
+  session.on("reconnected", () => {
+    serial(install);
+  });
+  const poll = async () => {
+    for (;; ) {
+      await sleep(pollMs);
+      if (stopped)
+        return;
+      await serial(drain);
+    }
+  };
+  poll();
+  return ok({
+    async entries(query = {}) {
+      await serial(drain);
+      if (query.id !== undefined)
+        return buffer.filter((entry) => entry.id === query.id);
+      return query.last === undefined ? [...buffer] : buffer.slice(-query.last);
+    },
+    async clear() {
+      await serial(drain);
+      buffer = [];
+    },
+    async writeJsonl(path) {
+      await serial(drain);
+      await writeJsonl(path, buffer);
+    },
+    stop() {
+      stopped = true;
+    }
+  });
+}
+
+// ../../packages/e2e/src/devtools/inspector.ts
+import { z as z5 } from "zod";
+var DECOY_VM = "don't use";
+var STATUS_RUNNING = "packager-status:running";
+var HTTP_TIMEOUT_MS = 3000;
+var inspectorTargetSchema = z5.looseObject({
+  id: z5.string(),
+  title: z5.string().optional(),
+  description: z5.string().optional(),
+  vm: z5.string().optional(),
+  deviceName: z5.string().optional(),
+  appId: z5.string().optional(),
+  webSocketDebuggerUrl: z5.string(),
+  reactNative: z5.looseObject({
+    logicalDeviceId: z5.string().optional(),
+    capabilities: z5.looseObject({ prefersFuseboxFrontend: z5.boolean().optional() }).optional()
+  }).optional()
+});
+function unavailable(message) {
+  return devtoolsErr("devtools_unavailable", message);
+}
+async function get(fetch2, url) {
+  try {
+    const res = await fetch2(url, { signal: AbortSignal.timeout(HTTP_TIMEOUT_MS) });
+    return { ok: res.ok, status: res.status, body: await res.text() };
+  } catch {
+    return;
+  }
+}
+function parseTargets(body) {
+  let json;
+  try {
+    json = JSON.parse(body);
+  } catch {
+    return;
+  }
+  if (!Array.isArray(json))
+    return;
+  const targets = [];
+  for (const entry of json) {
+    const parsed = inspectorTargetSchema.safeParse(entry);
+    if (parsed.success)
+      targets.push(parsed.data);
+  }
+  return targets;
+}
+async function listTargets(metroUrl, fetch2) {
+  const base = metroUrl.replace(/\/+$/, "");
+  const status = await get(fetch2, `${base}/status`);
+  if (!status)
+    return unavailable(`Metro is not reachable at ${base}`);
+  if (!status.body.includes(STATUS_RUNNING)) {
+    return unavailable(`${base} did not answer like Metro (got: ${status.body.slice(0, 80)})`);
+  }
+  for (const path of ["/json/list", "/json"]) {
+    const res = await get(fetch2, `${base}${path}`);
+    if (!res?.ok)
+      continue;
+    const targets = parseTargets(res.body);
+    if (targets)
+      return ok(targets.filter((t) => t.vm !== DECOY_VM));
+  }
+  return unavailable(`Metro at ${base} listed no inspector targets (/json/list and /json failed)`);
+}
+function urlDevice(target) {
+  try {
+    return new URL(target.webSocketDebuggerUrl).searchParams.get("device") ?? undefined;
+  } catch {
+    return;
+  }
+}
+function logicalIdOf(target) {
+  return target.reactNative?.logicalDeviceId ?? urlDevice(target);
+}
+function deviceKey(target) {
+  return logicalIdOf(target) ?? target.deviceName ?? target.id;
+}
+function pageNumber(target) {
+  const n = Number.parseInt(target.id.slice(target.id.lastIndexOf("-") + 1), 10);
+  return Number.isNaN(n) ? -1 : n;
+}
+function newestFirst(a, b) {
+  return pageNumber(b) - pageNumber(a) || (b.id > a.id ? 1 : b.id < a.id ? -1 : 0);
+}
+var isFusebox = (t) => t.reactNative?.capabilities?.prefersFuseboxFrontend === true || t.description?.endsWith("[C++ connection]") === true;
+function describeDevices(targets) {
+  const seen = new Map;
+  for (const t of targets) {
+    const key = deviceKey(t);
+    if (!seen.has(key))
+      seen.set(key, `${t.deviceName ?? "unknown"} (${logicalIdOf(t) ?? "no logicalDeviceId"})`);
+  }
+  return [...seen.values()].join(", ");
+}
+function normalizeWsUrl(wsUrl, metroUrl) {
+  const ws = new URL(wsUrl);
+  const metro = new URL(metroUrl);
+  ws.protocol = metro.protocol === "https:" ? "wss:" : "ws:";
+  ws.hostname = metro.hostname;
+  ws.port = metro.port;
+  return ws.toString();
+}
+function selectTarget(targets, query, metroUrl) {
+  if (targets.length === 0)
+    return unavailable("Metro has no inspector targets: is the app running a dev client?");
+  let candidates = [...targets];
+  const wanted = [
+    [
+      query.logicalDeviceId,
+      (t) => t.reactNative?.logicalDeviceId === query.logicalDeviceId || urlDevice(t) === query.logicalDeviceId,
+      "logicalDeviceId"
+    ],
+    [query.deviceName, (t) => t.deviceName === query.deviceName, "deviceName"]
+  ];
+  for (const [value, matches, label] of wanted) {
+    if (!value)
+      continue;
+    const filtered = candidates.filter(matches);
+    if (filtered.length > 0) {
+      candidates = filtered;
+      break;
+    }
+    if (new Set(candidates.map(deviceKey)).size > 1) {
+      return devtoolsErr("device_mismatch", `No debugger target matches ${label} "${value}". Metro serves: ${describeDevices(candidates)}`);
+    }
+  }
+  if (query.appId) {
+    const byApp = candidates.filter((t) => t.appId === query.appId);
+    if (byApp.length > 0)
+      candidates = byApp;
+  }
+  candidates.sort(newestFirst);
+  const fuseboxTarget = candidates.find(isFusebox);
+  const bridge = candidates.find((t) => t.title?.startsWith("React Native Bridge"));
+  const chosen = fuseboxTarget ?? bridge ?? candidates[0];
+  if (!chosen)
+    return unavailable("Metro has no inspector targets: is the app running a dev client?");
+  return ok({
+    wsUrl: normalizeWsUrl(chosen.webSocketDebuggerUrl, metroUrl),
+    deviceName: chosen.deviceName ?? chosen.title ?? "unknown",
+    appId: chosen.appId,
+    logicalDeviceId: logicalIdOf(chosen),
+    fusebox: fuseboxTarget !== undefined,
+    id: chosen.id,
+    title: chosen.title
+  });
+}
+
+// ../../packages/e2e/src/devtools/session.ts
+var WARDEN_BINDING = "__warden_cb";
+var RECONNECT_BACKOFF_MS = 200;
+var FAST_RECONNECT_ATTEMPTS = 10;
+var MAX_RECONNECT_BACKOFF_MS = 1000;
+var RECONNECT_BUDGET_MS = 30000;
+var RELOAD_WAIT_MS = 5000;
+var HANDSHAKE_OPTIONAL_TIMEOUT_MS = 3000;
+var RELOAD_EXPRESSION = '(function(){var g=globalThis;if(g.expo&&typeof g.expo.reloadAppAsync==="function"){setTimeout(function(){g.expo.reloadAppAsync("warden e2e reloadJs")},0);return "expo"}var m=g.nativeModuleProxy&&g.nativeModuleProxy.DevSettings;if(m&&typeof m.reload==="function"){setTimeout(function(){m.reload()},0);return "devsettings"}return false})()';
+var timerSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function connectDevtools(o) {
+  const { metroUrl } = o;
+  if (!metroUrl) {
+    return devtoolsErr("devtools_unavailable", "no Metro URL: release builds have no devtools (start a dev client)");
+  }
+  const sleep = o.sleep ?? timerSleep2;
+  const log = o.log ?? (() => {
+    return;
+  });
+  const now = o.now ?? Date.now;
+  const backoffMs = o.reconnectBackoffMs ?? RECONNECT_BACKOFF_MS;
+  const maxBackoffMs = Math.max(backoffMs, o.maxReconnectBackoffMs ?? MAX_RECONNECT_BACKOFF_MS);
+  const maxAttempts = o.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
+  const budgetMs = o.reconnectBudgetMs ?? RECONNECT_BUDGET_MS;
+  const backoffAfter = (attempt) => attempt <= FAST_RECONNECT_ATTEMPTS ? backoffMs : Math.min(maxBackoffMs, backoffMs * 2 ** (attempt - FAST_RECONNECT_ATTEMPTS));
+  let pinnedLogicalId = o.device.logicalDeviceId;
+  let state = { kind: "closed" };
+  const phase = () => state.kind;
+  let epoch = 0;
+  const epochWaiters = new Set;
+  const cdpHandlers = new Map;
+  const eventHandlers = {
+    reconnected: new Set,
+    lost: new Set
+  };
+  let unsubscribeCdp = [];
+  let connection = 0;
+  const taps = new Set(o.taps ?? []);
+  async function handshake(cdp, target) {
+    const optional = { timeoutMs: HANDSHAKE_OPTIONAL_TIMEOUT_MS };
+    await cdp.send("FuseboxClient.setClientMetadata", {}, optional);
+    await cdp.send("ReactNativeApplication.enable", {}, optional);
+    const enabled = await cdp.send("Runtime.enable");
+    if (!enabled.success)
+      return enabled;
+    await cdp.send("Runtime.runIfWaitingForDebugger", {}, optional);
+    const binding = await cdp.addBinding(WARDEN_BINDING);
+    if (!binding.success)
+      return binding;
+    return ok({ cdp, target });
+  }
+  async function establish() {
+    const listed = await listTargets(metroUrl, o.fetch);
+    if (!listed.success)
+      return listed;
+    const selected = selectTarget(listed.data, { deviceName: o.device.deviceName, logicalDeviceId: pinnedLogicalId, appId: o.device.appId }, metroUrl);
+    if (!selected.success)
+      return selected;
+    const opened = await openCdp(selected.data.wsUrl, { WebSocket: o.WebSocket, timeoutMs: o.timeoutMs });
+    if (!opened.success)
+      return opened;
+    const connectionNumber = ++connection;
+    let replay = true;
+    opened.data.onAny((method, params) => {
+      for (const tap of [...taps])
+        tap({ method, params, connection: connectionNumber, replay });
+    });
+    const attached = await handshake(opened.data, selected.data);
+    replay = false;
+    if (!attached.success)
+      opened.data.close();
+    return attached;
+  }
+  function attach(attached) {
+    state = { kind: "up", attached };
+    pinnedLogicalId = attached.target.logicalDeviceId ?? pinnedLogicalId;
+    for (const off of unsubscribeCdp)
+      off();
+    unsubscribeCdp = [];
+    for (const [method, handlers] of cdpHandlers) {
+      for (const handler of handlers)
+        unsubscribeCdp.push(attached.cdp.on(method, handler));
+    }
+    attached.cdp.onClose(() => {
+      if (state.kind === "up" && state.attached.cdp === attached.cdp)
+        reconnect("socket closed");
+    });
+    attached.cdp.on("Runtime.executionContextsCleared", () => {
+      if (state.kind === "up" && state.attached.cdp === attached.cdp)
+        reconnect("JS context cleared");
+    });
+  }
+  function reconnect(reason) {
+    if (state.kind === "reconnecting")
+      return state.done;
+    if (state.kind !== "up")
+      return Promise.resolve(devtoolsErr("cdp_closed", "devtools session is closed"));
+    const previous = state.attached;
+    log(`devtools: ${reason}, reconnecting`);
+    const done = (async () => {
+      previous.cdp.close();
+      let last = { code: "devtools_unavailable", message: "reconnect failed" };
+      const startedAt = now();
+      let slept = 0;
+      const leftMs = () => budgetMs - Math.max(now() - startedAt, slept);
+      for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+        if (phase() === "closed")
+          return devtoolsErr("cdp_closed", "devtools session is closed");
+        const result = await establish();
+        if (result.success) {
+          if (phase() === "closed") {
+            result.data.cdp.close();
+            return devtoolsErr("cdp_closed", "devtools session is closed");
+          }
+          attach(result.data);
+          log(`devtools: reconnected to ${result.data.target.id}`);
+          for (const handler of [...eventHandlers.reconnected])
+            handler(result.data.target);
+          return result;
+        }
+        last = result.error;
+        const left = leftMs();
+        const cap = Number.isFinite(maxAttempts) ? `/${maxAttempts}` : "";
+        log(`devtools: reconnect attempt ${attempt}${cap} failed: ${last.message}`);
+        if (attempt >= maxAttempts || left <= 0)
+          break;
+        const pause = Math.min(backoffAfter(attempt), left);
+        slept += pause;
+        await sleep(pause);
+      }
+      if (phase() !== "closed") {
+        state = { kind: "lost", error: last };
+        for (const handler of [...eventHandlers.lost])
+          handler(last);
+      }
+      return { success: false, error: last };
+    })();
+    state = { kind: "reconnecting", done };
+    epoch++;
+    for (const wake of [...epochWaiters])
+      wake();
+    return done;
+  }
+  function revive() {
+    log("devtools: lost, trying to attach again");
+    const done = (async () => {
+      const result = await establish();
+      if (phase() === "closed") {
+        if (result.success)
+          result.data.cdp.close();
+        return devtoolsErr("cdp_closed", "devtools session is closed");
+      }
+      if (!result.success) {
+        state = { kind: "lost", error: result.error };
+        return result;
+      }
+      attach(result.data);
+      log(`devtools: reconnected to ${result.data.target.id}`);
+      for (const handler of [...eventHandlers.reconnected])
+        handler(result.data.target);
+      return result;
+    })();
+    state = { kind: "reconnecting", done };
+    return done;
+  }
+  async function current() {
+    if (state.kind === "up")
+      return ok(state.attached);
+    if (state.kind === "reconnecting")
+      return state.done;
+    if (state.kind === "lost")
+      return revive();
+    return devtoolsErr("cdp_closed", "devtools session is closed");
+  }
+  const first = await establish();
+  if (!first.success)
+    return first;
+  attach(first.data);
+  log(`devtools: attached to ${first.data.target.id} (${first.data.target.fusebox ? "Fusebox" : "legacy"})`);
+  const session = {
+    async evaluate(expression, options = {}) {
+      const live = await current();
+      if (!live.success)
+        return { success: false, error: { message: live.error.message, code: live.error.code } };
+      const reply = await live.data.cdp.send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: options.await ?? false }, { timeoutMs: options.timeoutMs });
+      if (!reply.success)
+        return { success: false, error: { message: reply.error.message, code: reply.error.code } };
+      const { value, exceptionDetails } = readEvaluateReply(reply.data);
+      if (exceptionDetails) {
+        return {
+          success: false,
+          error: { message: describeException(exceptionDetails), code: "eval_failed", exceptionDetails }
+        };
+      }
+      return ok(value);
+    },
+    async reloadJs() {
+      const live = await current();
+      if (!live.success)
+        return live;
+      const startedAt = epoch;
+      const waitMs = o.reloadWaitMs ?? RELOAD_WAIT_MS;
+      const probe = await live.data.cdp.send("Runtime.evaluate", {
+        expression: RELOAD_EXPRESSION,
+        returnByValue: true
+      });
+      if (!probe.success) {
+        log(`devtools: reload probe failed: ${probe.error.message}`);
+        return devtoolsErr(probe.error.code, `reload probe failed: ${probe.error.message}`);
+      }
+      const method = readReloadMethod(probe.data) ?? "http";
+      if (method === "http") {
+        log("devtools: reload via http");
+        try {
+          const res = await o.fetch(`${metroUrl.replace(/\/+$/, "")}/reload`, { method: "POST" });
+          if (!res.ok) {
+            return devtoolsErr("devtools_unavailable", `reload failed: POST /reload answered ${res.status}`);
+          }
+        } catch (error) {
+          return devtoolsErr("devtools_unavailable", `reload failed: POST /reload threw ${String(error)}`);
+        }
+      } else {
+        log(`devtools: reload via ${method}`);
+      }
+      if (epoch === startedAt) {
+        await new Promise((resolve) => {
+          const wake = () => {
+            epochWaiters.delete(wake);
+            resolve();
+          };
+          epochWaiters.add(wake);
+          sleep(waitMs).then(wake);
+        });
+      }
+      if (epoch === startedAt && state.kind === "up") {
+        log(`devtools: reload via ${method} not observed after ${waitMs} ms`);
+        return devtoolsErr("reload_failed", `reload via ${method} acknowledged but the JS context did not restart within ${waitMs} ms`);
+      }
+      if (state.kind === "reconnecting") {
+        const back = await state.done;
+        if (!back.success)
+          return back;
+      }
+      return ok({ method });
+    },
+    get target() {
+      if (state.kind === "up")
+        return state.attached.target;
+      return first.data.target;
+    },
+    get bindingAvailable() {
+      return state.kind === "up" && state.attached.cdp.bindingAvailable === true;
+    },
+    async send(method, params, options) {
+      const live = await current();
+      if (!live.success)
+        return live;
+      return live.data.cdp.send(method, params, options);
+    },
+    onEvent(tap) {
+      taps.add(tap);
+      return () => {
+        taps.delete(tap);
+      };
+    },
+    onCdp(method, handler) {
+      let set = cdpHandlers.get(method);
+      if (!set) {
+        set = new Set;
+        cdpHandlers.set(method, set);
+      }
+      set.add(handler);
+      const off = state.kind === "up" ? state.attached.cdp.on(method, handler) : undefined;
+      if (off)
+        unsubscribeCdp.push(off);
+      return () => {
+        set.delete(handler);
+        off?.();
+      };
+    },
+    async evaluateWithBinding(script, requestId, timeoutMs) {
+      const live = await current();
+      if (!live.success)
+        return live;
+      return live.data.cdp.evaluateWithBinding(script, requestId, timeoutMs);
+    },
+    on(event, handler) {
+      const handlers = eventHandlers[event];
+      handlers.add(handler);
+      return () => {
+        handlers.delete(handler);
+      };
+    },
+    close() {
+      const previous = state;
+      state = { kind: "closed" };
+      if (previous.kind === "up")
+        previous.attached.cdp.close();
+      for (const wake of [...epochWaiters])
+        wake();
+    }
+  };
+  return ok(session);
+}
+function readReloadMethod(data) {
+  if (typeof data !== "object" || data === null || !("result" in data))
+    return;
+  const { result } = data;
+  if (typeof result !== "object" || result === null || !("value" in result))
+    return;
+  return result.value === "expo" || result.value === "devsettings" ? result.value : undefined;
+}
+
+// ../../packages/e2e/src/devtools/tree.ts
+import { z as z6 } from "zod";
+
+// ../../packages/e2e/src/devtools/tree.script.ts
+var TREE_SCRIPT = `function (cfg, g) {
+  var rid = cfg.requestId;
+  var MAX = typeof cfg.max === "number" && cfg.max > 0 ? Math.min(Math.floor(cfg.max), 5000) : 5000;
+  var GUARD = typeof cfg.guardMs === "number" && cfg.guardMs > 0 ? cfg.guardMs : 1200;
+  var ALL = cfg.all === true;
+  var ONLY = typeof cfg.screen === "string" && cfg.screen !== "" ? cfg.screen : null;
+  var BUDGET = 300000;
+  var MAX_DEPTH = 1500;
+  var MEASURE_CAP = 8000;
+  var TEXT_CAP = 200;
+  var HOST_NAMES = {
+    RCTView: "View",
+    RCTText: "Text",
+    RCTVirtualText: "Text",
+    RCTScrollView: "ScrollView",
+    RCTImageView: "Image",
+    RCTSinglelineTextInputView: "TextInput",
+    RCTMultilineTextInputView: "TextInput",
+    AndroidTextInput: "TextInput"
+  };
+  var EMPTY = {};
+  var visits = 0;
+  var budgetHit = false;
+  var delivered = false;
+  var finished = false;
+  var timer = null;
+  var bestScreen = null;
+  var bestDepth = -1;
+  var onlyFound = false;
+  var hostMap = new Map();
+  var hostList = [];
+  var rects = [];
+  var forest = [];
+  var pending = 0;
+
+  function isObj(v) {
+    return v !== null && typeof v === "object";
+  }
+
+  function str(v) {
+    return typeof v === "string" && v !== "" ? v : undefined;
+  }
+
+  function message(e) {
+    return String(e && e.message ? e.message : e);
+  }
+
+  function deliver(result) {
+    if (delivered) return;
+    delivered = true;
+    var cb = g[cfg.binding];
+    if (typeof cb === "function") {
+      cb(JSON.stringify({ requestId: rid, result: result }));
+      return;
+    }
+    var store = g.__warden_tree_results;
+    if (!isObj(store)) {
+      store = {};
+      g.__warden_tree_results = store;
+    }
+    store[rid] = JSON.stringify(result);
+  }
+
+  function lastDisplay(style, depth) {
+    if (!style || depth > 6) return undefined;
+    if (Array.isArray(style)) {
+      var found;
+      for (var i = 0; i < style.length; i++) {
+        var d = lastDisplay(style[i], depth + 1);
+        if (d !== undefined) found = d;
+      }
+      return found;
+    }
+    return typeof style === "object" ? style.display : undefined;
+  }
+
+  function isHidden(props) {
+    return props.activityState === 0 ||
+      props.isPageFocused === false ||
+      props.freeze === true ||
+      props["aria-hidden"] === true ||
+      props.accessibilityElementsHidden === true ||
+      props.importantForAccessibility === "no-hide-descendants" ||
+      lastDisplay(props.style, 0) === "none";
+  }
+
+  function typeName(t, depth) {
+    if (typeof t === "function") return t.displayName || t.name || "";
+    if (typeof t === "string") return t;
+    if (isObj(t) && depth < 4) {
+      return t.displayName || typeName(t.render, depth + 1) || typeName(t.type, depth + 1) || "";
+    }
+    return "";
+  }
+
+  function nameOf(f) {
+    var t = f.type;
+    if (f.tag === 5 && typeof t === "string") {
+      return Object.prototype.hasOwnProperty.call(HOST_NAMES, t) ? HOST_NAMES[t] : t;
+    }
+    return typeName(t, 0) || "Component";
+  }
+
+  function rectHostOf(f) {
+    if (f.tag === 5) return f;
+    var cur = f.child;
+    var n = 0;
+    while (cur && n < 30) {
+      if (cur.sibling) return null;
+      if (cur.tag === 5) return cur;
+      if (cur.tag === 6) return null;
+      cur = cur.child;
+      n++;
+    }
+    return null;
+  }
+
+  function registerHost(h) {
+    if (!h) return -1;
+    var i = hostMap.get(h);
+    if (i === undefined) {
+      if (hostList.length >= MEASURE_CAP) return -1;
+      i = hostList.length;
+      hostList.push(h);
+      hostMap.set(h, i);
+    }
+    return i;
+  }
+
+  function clip(t) {
+    return t.length > TEXT_CAP ? t.slice(0, TEXT_CAP) : t;
+  }
+
+  function buildChildren(f, ctx, depth) {
+    var nodes = [];
+    var strings = [];
+    if (depth >= MAX_DEPTH) {
+      budgetHit = true;
+      return { nodes: nodes, strings: strings };
+    }
+    var c = f.child;
+    while (c) {
+      var r = buildFiber(c, ctx, depth + 1);
+      for (var i = 0; i < r.nodes.length; i++) nodes.push(r.nodes[i]);
+      for (var j = 0; j < r.strings.length; j++) strings.push(r.strings[j]);
+      c = c.sibling;
+    }
+    return { nodes: nodes, strings: strings };
+  }
+
+  function buildFiber(f, ctx, depth) {
+    visits++;
+    if (visits > BUDGET) {
+      budgetHit = true;
+      return { nodes: [], strings: [] };
+    }
+    if (f.tag === 6) {
+      var s = f.memoizedProps;
+      if (typeof s === "string" || typeof s === "number") return { nodes: [], strings: [String(s)] };
+      return { nodes: [], strings: [] };
+    }
+    var props = isObj(f.memoizedProps) ? f.memoizedProps : EMPTY;
+    var route = props.route;
+    var nav = props.navigation;
+    var screenRoot = isObj(route) && typeof route.name === "string" && isObj(nav);
+    var focused;
+    if (screenRoot && typeof nav.isFocused === "function") {
+      try {
+        focused = nav.isFocused() === true;
+      } catch (e) {
+        focused = undefined;
+      }
+    }
+    var hidden = isHidden(props) || focused === false;
+    if (ONLY === null && hidden && !ALL) return { nodes: [], strings: [] };
+    var inactive = ctx.inactive || (ONLY === null && hidden);
+    var inScreen = ctx.inScreen;
+    if (ONLY !== null && screenRoot && route.name === ONLY) {
+      inScreen = true;
+      onlyFound = true;
+    }
+    if (ONLY === null && screenRoot && focused === true && !inactive && depth > bestDepth) {
+      bestDepth = depth;
+      bestScreen = route.name;
+    }
+    var childCtx = ctx;
+    if (inactive !== ctx.inactive || inScreen !== ctx.inScreen) childCtx = { inactive: inactive, inScreen: inScreen };
+    var kids = buildChildren(f, childCtx, depth);
+
+    var type = f.type;
+    var isHost = f.tag === 5 && typeof type === "string";
+    var isText = isHost && (type === "RCTText" || type === "Text");
+    var isVirtual = isHost && type === "RCTVirtualText";
+    var testID = str(props.testID);
+    var label = str(props.accessibilityLabel) || str(props["aria-label"]);
+    var strings = kids.strings;
+    var text;
+    var outStrings = strings;
+    if (isText) {
+      var joined = clip(strings.join(""));
+      text = joined === "" ? undefined : joined;
+      outStrings = [];
+    }
+    var emit = (ONLY === null || inScreen) &&
+      (testID !== undefined || label !== undefined || screenRoot || (isText && text !== undefined));
+    if (!emit) return { nodes: kids.nodes, strings: outStrings };
+    if (!isText && strings.length > 0) {
+      text = clip(strings.join(isVirtual ? "" : " "));
+      if (!isVirtual) outStrings = [];
+    }
+    var node = {
+      name: nameOf(f),
+      testID: testID,
+      label: label,
+      text: text,
+      hostIdx: registerHost(rectHostOf(f)),
+      kids: kids.nodes,
+      inactive: inactive,
+      screenRoot: screenRoot,
+      rect: undefined
+    };
+    return { nodes: [node], strings: outStrings };
+  }
+
+  function r1(v) {
+    return Math.round(v * 10) / 10;
+  }
+
+  function accept(i, x, y, w, h) {
+    if (finished) return;
+    if (typeof x !== "number" || typeof y !== "number" || typeof w !== "number" || typeof h !== "number") return;
+    if (!isFinite(x) || !isFinite(y) || !isFinite(w) || !isFinite(h) || w <= 0 || h <= 0) return;
+    rects[i] = { x: r1(x), y: r1(y), w: r1(w), h: r1(h) };
+  }
+
+  function done() {
+    pending--;
+    if (pending === 0) finish();
+  }
+
+  function measure(i) {
+    var sn = hostList[i].stateNode;
+    var settled = false;
+    function viaWindow(x, y, w, h) {
+      if (settled) return;
+      settled = true;
+      accept(i, x, y, w, h);
+      done();
+    }
+    function viaShadow(x, y, w, h, px, py) {
+      if (settled) return;
+      settled = true;
+      accept(i, px, py, w, h);
+      done();
+    }
+    try {
+      if (isObj(sn)) {
+        var pub = isObj(sn.canonical) ? sn.canonical.publicInstance : null;
+        if (isObj(pub) && typeof pub.measureInWindow === "function") {
+          pub.measureInWindow(viaWindow);
+          return;
+        }
+        if (typeof sn.measureInWindow === "function") {
+          sn.measureInWindow(viaWindow);
+          return;
+        }
+        var fab = g.nativeFabricUIManager;
+        if (sn.node && isObj(fab) && typeof fab.measure === "function") {
+          fab.measure(sn.node, viaShadow);
+          return;
+        }
+        var tag = typeof sn._nativeTag === "number"
+          ? sn._nativeTag
+          : (isObj(sn.canonical) && typeof sn.canonical.nativeTag === "number" ? sn.canonical.nativeTag : undefined);
+        var proxy = g.nativeModuleProxy;
+        var ui = isObj(proxy) ? proxy.UIManager : null;
+        if (tag !== undefined && isObj(ui) && typeof ui.measureInWindow === "function") {
+          ui.measureInWindow(tag, viaWindow);
+          return;
+        }
+      }
+    } catch (e) {
+    }
+    if (!settled) {
+      settled = true;
+      done();
+    }
+  }
+
+  function sameRect(a, b) {
+    if (a === undefined || b === undefined) return a === b;
+    return Math.abs(a.x - b.x) <= 1 && Math.abs(a.y - b.y) <= 1 && Math.abs(a.w - b.w) <= 1 && Math.abs(a.h - b.h) <= 1;
+  }
+
+  function canAbsorb(p, c) {
+    return !p.screenRoot &&
+      !!p.inactive === !!c.inactive &&
+      sameRect(p.rect, c.rect) &&
+      (c.testID === undefined || c.testID === p.testID) &&
+      (c.label === undefined || c.label === p.label);
+  }
+
+  function finalize(nodes) {
+    var out = [];
+    for (var i = 0; i < nodes.length; i++) {
+      var n = nodes[i];
+      n.rect = n.hostIdx >= 0 ? rects[n.hostIdx] : undefined;
+      n.kids = finalize(n.kids);
+      if (n.rect === undefined && n.testID === undefined) {
+        for (var k = 0; k < n.kids.length; k++) out.push(n.kids[k]);
+        continue;
+      }
+      while (n.kids.length === 1 && canAbsorb(n, n.kids[0])) {
+        var c = n.kids[0];
+        if (n.testID === undefined) n.testID = c.testID;
+        if (n.label === undefined) n.label = c.label;
+        if (n.text === undefined) n.text = c.text;
+        n.screenRoot = n.screenRoot || c.screenRoot;
+        n.kids = c.kids;
+      }
+      out.push(n);
+    }
+    return out;
+  }
+
+  var comps = [];
+  var more = false;
+
+  function flatten(nodes, parentId) {
+    for (var i = 0; i < nodes.length; i++) {
+      if (comps.length >= MAX) {
+        more = true;
+        return;
+      }
+      var n = nodes[i];
+      var id = comps.length;
+      var c = { id: id, name: n.name, parent: parentId };
+      if (n.testID !== undefined) c.testID = n.testID;
+      if (n.label !== undefined) c.label = n.label;
+      if (n.text !== undefined) c.text = n.text;
+      if (n.rect !== undefined) c.rect = n.rect;
+      if (n.inactive) c.inactive = true;
+      comps.push(c);
+      flatten(n.kids, id);
+    }
+  }
+
+  function finish() {
+    if (finished) return;
+    finished = true;
+    if (timer !== null && typeof g.clearTimeout === "function") g.clearTimeout(timer);
+    try {
+      flatten(finalize(forest), null);
+      var result = { components: comps, truncated: more || budgetHit };
+      var screen = ONLY !== null ? (onlyFound ? ONLY : null) : bestScreen;
+      if (screen !== null) result.screen = screen;
+      deliver(result);
+    } catch (e) {
+      deliver({ error: message(e) });
+    }
+  }
+
+  function countFibers(start) {
+    var n = 0;
+    var cur = start;
+    while (cur && n < 20000) {
+      n++;
+      if (cur.child) {
+        cur = cur.child;
+        continue;
+      }
+      while (cur && cur !== start && !cur.sibling) cur = cur.return;
+      if (!cur || cur === start) break;
+      cur = cur.sibling;
+    }
+    return n;
+  }
+
+  try {
+    var hook = g.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!isObj(hook)) {
+      deliver({ error: "no-hook" });
+      return "started";
+    }
+    var best = null;
+    var bestCount = -1;
+    var consider = function (set) {
+      if (!set || typeof set.forEach !== "function") return;
+      set.forEach(function (root) {
+        var cur = root && root.current;
+        if (!cur) return;
+        var n = countFibers(cur);
+        if (n > bestCount) {
+          bestCount = n;
+          best = cur;
+        }
+      });
+    };
+    if (typeof hook.getFiberRoots === "function") {
+      if (isObj(hook.renderers) && typeof hook.renderers.forEach === "function") {
+        hook.renderers.forEach(function (renderer, id) {
+          consider(hook.getFiberRoots(id));
+        });
+      }
+      if (best === null) consider(hook.getFiberRoots(1));
+    }
+    if (best === null) {
+      deliver({ error: "no-roots" });
+      return "started";
+    }
+    forest = buildChildren(best, { inactive: false, inScreen: false }, 0).nodes;
+    if (hostList.length === 0) {
+      finish();
+      return "started";
+    }
+    pending = hostList.length + 1;
+    for (var i = 0; i < hostList.length; i++) measure(i);
+    done();
+    if (!finished) {
+      if (typeof g.setTimeout === "function") timer = g.setTimeout(finish, GUARD);
+      else finish();
+    }
+  } catch (e) {
+    deliver({ error: message(e) });
+  }
+  return "started";
+}`;
+function treeInstallExpression(config) {
+  const globalObject = 'typeof globalThis !== "undefined" ? globalThis : (typeof global !== "undefined" ? global : this)';
+  return `(${TREE_SCRIPT})(${JSON.stringify(config)}, ${globalObject})`;
+}
+
+// ../../packages/e2e/src/devtools/tree.ts
+var DEFAULT_TIMEOUT_MS3 = 5000;
+var POLL_MS = 50;
+var rectSchema = z6.object({ x: z6.number(), y: z6.number(), w: z6.number(), h: z6.number() });
+var componentSchema = z6.object({
+  id: z6.number(),
+  name: z6.string(),
+  testID: z6.string().optional(),
+  label: z6.string().optional(),
+  text: z6.string().optional(),
+  parent: z6.number().nullable(),
+  rect: rectSchema.optional(),
+  inactive: z6.literal(true).optional()
+});
+var scriptResultSchema = z6.union([
+  z6.object({ error: z6.string() }),
+  z6.object({ screen: z6.string().optional(), components: z6.array(componentSchema), truncated: z6.boolean() })
+]);
+var bindingPayloadSchema2 = z6.object({ requestId: z6.string(), result: z6.unknown() });
+var timerSleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var requestCounter = 0;
+function scriptError(message) {
+  if (message === "no-hook")
+    return devtoolsErr("devtools_unavailable", "React DevTools hook not present (release build?)");
+  if (message === "no-roots")
+    return devtoolsErr("devtools_unavailable", "no React root is mounted yet");
+  return devtoolsErr("eval_failed", `React tree script failed: ${message}`);
+}
+var scale = (value, ratio) => Math.round(value * ratio * 10) / 10;
+function toTree(data, pixelRatio) {
+  const parsed = scriptResultSchema.safeParse(data);
+  if (!parsed.success)
+    return devtoolsErr("cdp_protocol", `unexpected React tree payload: ${parsed.error.message}`);
+  if ("error" in parsed.data)
+    return scriptError(parsed.data.error);
+  const { screen, components, truncated } = parsed.data;
+  const mapped = components.map(({ rect, ...rest }) => ({
+    ...rest,
+    ...rect ? {
+      rect: {
+        x: scale(rect.x, pixelRatio),
+        y: scale(rect.y, pixelRatio),
+        width: scale(rect.w, pixelRatio),
+        height: scale(rect.h, pixelRatio)
+      }
+    } : {}
+  }));
+  return ok({ ...screen === undefined ? {} : { screen }, components: mapped, truncated });
+}
+var pollExpression = (requestId) => `(function (g) { var s = g.__warden_tree_results; var v = s && s[${JSON.stringify(requestId)}]; ` + `if (typeof v !== "string") return null; delete s[${JSON.stringify(requestId)}]; return v; })` + `(typeof globalThis !== "undefined" ? globalThis : (typeof global !== "undefined" ? global : this))`;
+async function viaPolling(session, expression, requestId, timeoutMs, deps) {
+  const started = deps.now();
+  const installed = await session.evaluate(expression, { timeoutMs });
+  if (!installed.success)
+    return devtoolsErr(installed.error.code ?? "eval_failed", installed.error.message);
+  const poll = pollExpression(requestId);
+  for (;; ) {
+    const reply = await session.evaluate(poll, { timeoutMs });
+    if (!reply.success)
+      return devtoolsErr(reply.error.code ?? "eval_failed", reply.error.message);
+    if (typeof reply.data === "string") {
+      try {
+        return ok(JSON.parse(reply.data));
+      } catch {
+        return devtoolsErr("cdp_protocol", "React tree payload is not JSON");
+      }
+    }
+    if (deps.now() - started >= timeoutMs) {
+      return devtoolsErr("cdp_timeout", `the app did not report its React tree within ${timeoutMs} ms`);
+    }
+    await deps.sleep(POLL_MS);
+  }
+}
+async function viaBinding(session, expression, requestId, timeoutMs) {
+  const reply = await session.evaluateWithBinding(expression, requestId, timeoutMs);
+  if (!reply.success)
+    return reply.error.code === "binding_unavailable" ? undefined : reply;
+  const tagged = bindingPayloadSchema2.safeParse(reply.data);
+  return tagged.success ? ok(tagged.data.result) : devtoolsErr("cdp_protocol", "unexpected React tree binding payload");
+}
+async function fetchTree(session, options = {}, deps = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
+  const resolved = { sleep: deps.sleep ?? timerSleep3, now: deps.now ?? Date.now };
+  requestCounter += 1;
+  const requestId = `tree-${Date.now().toString(36)}-${requestCounter}`;
+  const config = {
+    requestId,
+    binding: WARDEN_BINDING,
+    ...options.max === undefined ? {} : { max: options.max },
+    ...options.screen === undefined ? {} : { screen: options.screen },
+    ...options.all === undefined ? {} : { all: options.all }
+  };
+  const expression = treeInstallExpression(config);
+  const bound = session.bindingAvailable ? await viaBinding(session, expression, requestId, timeoutMs) : undefined;
+  const payload = bound ?? await viaPolling(session, expression, requestId, timeoutMs, resolved);
+  if (!payload.success)
+    return payload;
+  return toTree(payload.data, options.pixelRatio ?? 1);
+}
+
+// ../../packages/e2e/src/devtools/facet.ts
+async function openDevtoolsFacet(o) {
+  const metroUrl = o.env.metroUrl;
+  if (!metroUrl) {
+    return devtoolsErr("devtools_unavailable", "no Metro URL (WARDEN_METRO_URL): release builds have no devtools");
+  }
+  const consoleCapture = createConsoleCapture({ ring: o.consoleRing, sink: o.consoleSink });
+  const connected = await connectDevtools({
+    metroUrl,
+    device: o.device,
+    fetch: o.fetch,
+    WebSocket: o.WebSocket,
+    log: o.log,
+    sleep: o.sleep,
+    timeoutMs: o.timeoutMs,
+    taps: [consoleCapture.handle]
+  });
+  if (!connected.success)
+    return connected;
+  const session = connected.data;
+  const attached = await attachNetwork(session, {
+    ring: o.networkRing,
+    metroUrl,
+    includeBodies: o.includeBodies,
+    pollMs: o.pollMs,
+    sleep: o.sleep,
+    sink: o.networkSink
+  });
+  if (!attached.success) {
+    session.close();
+    return attached;
+  }
+  const network = attached.data;
+  return ok({
+    evaluate: (expression, options) => session.evaluate(expression, options),
+    reloadJs: () => session.reloadJs(),
+    console: {
+      lines: consoleCapture.lines,
+      clear: consoleCapture.clear,
+      mark: consoleCapture.mark
+    },
+    network: { entries: network.entries, clear: network.clear },
+    tree: (options) => fetchTree(session, options, { sleep: o.sleep }),
+    get target() {
+      return session.target;
+    },
+    on: session.on,
+    async attachArtifacts(dir) {
+      const paths = { console: join(dir, "console.jsonl"), network: join(dir, "network.jsonl") };
+      try {
+        await consoleCapture.writeJsonl(paths.console);
+        await network.writeJsonl(paths.network);
+      } catch (error) {
+        return devtoolsErr("io_failed", `could not write devtools artifacts to ${dir}: ${String(error)}`);
+      }
+      return ok(paths);
+    },
+    close() {
+      network.stop();
+      session.close();
+    }
+  });
+}
+
+// ../../packages/e2e/src/driver/span-detail.ts
+import { AsyncLocalStorage } from "async_hooks";
+var collectors = new AsyncLocalStorage;
+function collectSpanDetail(notes, fn) {
+  return collectors.run(notes, fn);
+}
+function noteSpanDetail(key, value) {
+  const notes = collectors.getStore();
+  if (notes !== undefined)
+    notes[key] = value;
+}
+function addSpanDetail(key, amount) {
+  const notes = collectors.getStore();
+  if (notes === undefined)
+    return;
+  const before = notes[key];
+  notes[key] = (typeof before === "number" ? before : 0) + amount;
+}
+
+// ../../packages/e2e/src/driver/observation-cache.ts
+var OBSERVATION_MAX_AGE_MS = { ios: 150, android: 1000 };
+function canObserve(driver) {
+  return typeof driver.observe === "function";
+}
+function canDetectAlerts(driver) {
+  return typeof driver.alertIn === "function";
+}
+var READS = new Set([
+  "health",
+  "snapshot",
+  "elementAtPoint",
+  "screenshot",
+  "alert",
+  "alertOn",
+  "alertIn",
+  "isFrontmost",
+  "isInstalled",
+  "isRunning",
+  "observe",
+  "invalidateObservations",
+  "previous",
+  "peek"
+]);
+var READS_WITHOUT_ARGUMENT = new Set(["orientation", "appearance", "clipboard"]);
+function isCall(value) {
+  return typeof value === "function";
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function isWholeScreen(options) {
+  return options === undefined || options.interactiveOnly !== true && options.backend === undefined;
+}
+function cacheObservations(driver, options = {}) {
+  const now = options.now ?? Date.now;
+  const maxAgeMs = options.maxAgeMs ?? OBSERVATION_MAX_AGE_MS[driver.platform];
+  let generation = 0;
+  let kept;
+  let lastInputAt;
+  const moveOn = () => {
+    generation += 1;
+    kept = undefined;
+  };
+  const inputEdge = () => {
+    moveOn();
+    lastInputAt = now();
+  };
+  const previous = () => ({
+    snapshot: kept !== undefined && kept.generation === generation ? kept.snapshot : undefined,
+    generation,
+    sinceInputMs: lastInputAt === undefined ? undefined : now() - lastInputAt
+  });
+  const peek = () => kept !== undefined && kept.generation === generation ? { snapshot: kept.snapshot, ageMs: now() - kept.at } : undefined;
+  const usable = () => kept !== undefined && kept.generation === generation && now() - kept.at < maxAgeMs ? kept : undefined;
+  const keep = (snapshot2, startedIn) => {
+    if (startedIn !== generation)
+      return;
+    kept = { snapshot: snapshot2, generation, at: now(), alertRead: false };
+    return kept;
+  };
+  const observe = async ({ reuse }) => {
+    const hit = reuse ? usable() : undefined;
+    if (hit !== undefined) {
+      noteSpanDetail("observation", "cached");
+      return { success: true, data: hit.snapshot };
+    }
+    const startedIn = generation;
+    const taken = await driver.snapshot();
+    if (taken.success)
+      keep(taken.data, startedIn);
+    return taken;
+  };
+  const snapshot = async (opts) => {
+    const startedIn = generation;
+    const taken = await driver.snapshot(opts);
+    if (taken.success && isWholeScreen(opts))
+      keep(taken.data, startedIn);
+    return taken;
+  };
+  const alertFromSnapshot = (reader) => {
+    return async () => {
+      const hit = usable();
+      if (hit !== undefined && !hit.alertRead) {
+        hit.alertRead = true;
+        return { success: true, data: reader.alertIn(hit.snapshot) };
+      }
+      const startedIn = generation;
+      const taken = await driver.snapshot();
+      if (!taken.success)
+        return taken;
+      const fresh = keep(taken.data, startedIn);
+      if (fresh !== undefined)
+        fresh.alertRead = true;
+      return { success: true, data: reader.alertIn(taken.data) };
+    };
+  };
+  const asInput = (fn, target) => {
+    return (...args) => {
+      inputEdge();
+      let result;
+      try {
+        result = Reflect.apply(fn, target, args);
+      } catch (error) {
+        inputEdge();
+        throw error;
+      }
+      if (!isThenable(result)) {
+        inputEdge();
+        return result;
+      }
+      return Promise.resolve(result).finally(inputEdge);
+    };
+  };
+  const wrapMember = (name, value, target) => {
+    if (name === "app" && typeof value === "object" && value !== null)
+      return wrap(value, {});
+    if (!isCall(value) || READS.has(name))
+      return value;
+    const input = asInput(value, target);
+    if (!READS_WITHOUT_ARGUMENT.has(name))
+      return input;
+    return (...args) => args[0] === undefined ? Reflect.apply(value, target, args) : input(...args);
+  };
+  const wrap = (target, own2) => {
+    const wrapped = new Map;
+    return new Proxy(target, {
+      get(object, property) {
+        const value = Reflect.get(object, property, object);
+        if (typeof property !== "string")
+          return value;
+        if (property in own2)
+          return own2[property];
+        const cached = wrapped.get(property);
+        if (cached !== undefined && cached.source === value)
+          return cached.wrapper;
+        const wrapper = wrapMember(property, value, object);
+        wrapped.set(property, { source: value, wrapper });
+        return wrapper;
+      }
+    });
+  };
+  const own = { observe, invalidateObservations: moveOn, previous, peek, snapshot };
+  if (canDetectAlerts(driver))
+    own.alert = alertFromSnapshot(driver);
+  return wrap(driver, own);
+}
+
+// ../../packages/e2e/src/runner/span.ts
+function codeOf(error) {
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return "ERROR";
+}
+function writeSpan(sink, span, outcome) {
+  try {
+    const { ok: ok2, code, extra } = outcome();
+    const detail = { ...span.notes, ...extra };
+    sink.write({
+      type: "span",
+      ts: span.ts,
+      op: span.op,
+      ms: span.ms,
+      ok: ok2,
+      ...code === undefined ? {} : { code },
+      ...Object.keys(detail).length === 0 ? {} : { detail }
+    });
+  } catch {}
+}
+async function runSpan(sink, op, fn, options = {}) {
+  if (sink === undefined)
+    return fn();
+  const now = options.now ?? Date.now;
+  const notes = {};
+  const ts = now();
+  let value;
+  try {
+    value = await collectSpanDetail(notes, fn);
+  } catch (error) {
+    writeSpan(sink, { op, ts, ms: now() - ts, notes }, () => ({ ok: false, code: codeOf(error) }));
+    throw error;
+  }
+  writeSpan(sink, { op, ts, ms: now() - ts, notes }, () => ({
+    ...options.verdict?.(value) ?? { ok: true },
+    extra: options.detail?.(value)
+  }));
+  return value;
+}
+
+// ../../packages/e2e/src/driver/traced-driver.ts
+var UNTRACED = new Set(["close"]);
+function isThenable2(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function outcomeOf(value) {
+  if (typeof value !== "object" || value === null || !("success" in value) || value.success !== false) {
+    return { ok: true };
+  }
+  const error = "error" in value ? value.error : undefined;
+  const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+  return typeof code === "string" ? { ok: false, code } : { ok: false };
+}
+function traceDriver(driver, options) {
+  const now = options.now ?? Date.now;
+  const wrap = (target, prefix) => {
+    const wrapped = new Map;
+    return new Proxy(target, {
+      get(object, property) {
+        const value = Reflect.get(object, property, object);
+        if (typeof property !== "string")
+          return value;
+        const cached = wrapped.get(property);
+        if (cached !== undefined && cached.source === value)
+          return cached.wrapper;
+        if (property === "app" && typeof value === "object" && value !== null) {
+          const app = wrap(value, `${prefix}app.`);
+          wrapped.set(property, { source: value, wrapper: app });
+          return app;
+        }
+        if (typeof value !== "function" || UNTRACED.has(property))
+          return value;
+        const call = (...args) => {
+          const sink = options.trace();
+          if (sink === undefined)
+            return Reflect.apply(value, object, args);
+          const span = { op: `${prefix}${property}`, ts: now(), ms: 0, notes: {} };
+          const end = () => ({ ...span, ms: now() - span.ts });
+          let result;
+          try {
+            result = collectSpanDetail(span.notes, () => Reflect.apply(value, object, args));
+          } catch (error) {
+            writeSpan(sink, end(), () => ({ ok: false, code: codeOf(error) }));
+            throw error;
+          }
+          if (!isThenable2(result))
+            return result;
+          return Promise.resolve(result).then((resolved) => {
+            writeSpan(sink, end(), () => outcomeOf(resolved));
+            return resolved;
+          }, (error) => {
+            writeSpan(sink, end(), () => ({ ok: false, code: codeOf(error) }));
+            throw error;
+          });
+        };
+        wrapped.set(property, { source: value, wrapper: call });
+        return call;
+      }
+    });
+  };
+  return wrap(driver, "driver.");
+}
+
+// ../../packages/e2e/src/runner/results.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+import { z as z7 } from "zod";
+var testStatusSchema = z7.enum(["passed", "failed", "skipped", "timed-out"]);
+var testResultSchema = z7.object({
+  file: z7.string(),
+  title: z7.array(z7.string()),
+  status: testStatusSchema,
+  durationMs: z7.number(),
+  startedAt: z7.number(),
+  only: z7.boolean().optional(),
+  error: z7.object({
+    message: z7.string(),
+    code: z7.string().optional(),
+    stack: z7.string().optional()
+  }).optional(),
+  artifacts: z7.object({ dir: z7.string(), files: z7.array(z7.string()) }).optional(),
+  device: z7.object({
+    udid: z7.string(),
+    platform: z7.enum(["ios", "android"]),
+    name: z7.string().optional()
+  })
+});
+function openResults(path) {
+  let ready = false;
+  return {
+    path,
+    append(result) {
+      if (!ready) {
+        mkdirSync(dirname2(path), { recursive: true });
+        ready = true;
+      }
+      appendFileSync(path, `${JSON.stringify(result)}
+`);
+    }
+  };
+}
+
+// ../../packages/e2e/src/runner/step.ts
+function abortReason(signal) {
+  return signal.reason ?? new Error("aborted");
+}
+function aborted(signal) {
+  let dispose = () => {
+    return;
+  };
+  const promise = new Promise((_, reject) => {
+    if (signal.aborted) {
+      reject(abortReason(signal));
+      return;
+    }
+    const onAbort = () => reject(abortReason(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    dispose = () => signal.removeEventListener("abort", onAbort);
+  });
+  promise.catch(() => {
+    return;
+  });
+  return { promise, dispose };
+}
+async function runStep(attempt, kind, label, fn, now = Date.now) {
+  if (attempt === undefined)
+    return fn();
+  if (attempt.signal.aborted)
+    throw abortReason(attempt.signal);
+  const startedAt = now();
+  attempt.trace.write({ type: "step-start", ts: startedAt, kind, label });
+  attempt.depth += 1;
+  const abort = aborted(attempt.signal);
+  try {
+    const value = await Promise.race([fn(), abort.promise]);
+    attempt.depth -= 1;
+    attempt.trace.write({ type: "step-end", ts: now(), kind, label, status: "passed", ms: now() - startedAt });
+    return value;
+  } catch (error) {
+    attempt.depth -= 1;
+    attempt.trace.write({
+      type: "step-end",
+      ts: now(),
+      kind,
+      label,
+      status: "failed",
+      ms: now() - startedAt,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  } finally {
+    abort.dispose();
+  }
+}
+
+// ../../packages/e2e/src/session.ts
+function devtoolsTarget(env) {
+  return { appId: env.bundleId, ...env.deviceName === undefined ? {} : { deviceName: env.deviceName } };
+}
+var openDevtools = (env) => openDevtoolsFacet({
+  env: { metroUrl: env.metroUrl },
+  device: devtoolsTarget(env),
+  fetch,
+  WebSocket,
+  timeoutMs: 5000,
+  log: (line) => process.stderr.write(`[devtools] ${line}
+`)
+});
+var SESSION_KEY = Symbol.for("@delacour/warden-e2e/session");
+var slot = () => globalThis;
+var defaultFactory;
+var defaultFixtures;
+function setDefaultDriverFactory(factory) {
+  defaultFactory = factory;
+}
+function hasDefaultDriverFactory() {
+  return defaultFactory !== undefined;
+}
+function setDefaultFixtureFactory(factory) {
+  defaultFixtures = factory;
+}
+function hasDefaultFixtureFactory() {
+  return defaultFixtures !== undefined;
+}
+var missingFactory = async () => ({
+  success: false,
+  error: {
+    code: "E_INTERNAL",
+    message: "no driver factory configured (setDefaultDriverFactory was never called)",
+    retryable: false
+  }
+});
+function writeLine(line) {
+  try {
+    writeSync(1, `${line}
+`);
+  } catch {}
+}
+function resolveEnv(env) {
+  if (env !== undefined)
+    return env;
+  const read = readEnv(process.env);
+  if (!read.success)
+    throw new E2eError("SESSION", `invalid warden e2e environment:
+${read.error}`);
+  if (read.data === undefined)
+    throw new E2eError("SESSION", "not running under warden: WARDEN_UDID is not set");
+  return read.data;
+}
+function createSession(opts = {}) {
+  const resolved = resolveEnv(opts.env);
+  const factory = opts.driverFactory ?? defaultFactory ?? missingFactory;
+  const out = resolve(resolved.out);
+  mkdirSync2(out, { recursive: true });
+  const results = openResults(resolve(out, "results.jsonl"));
+  const idle = new AbortController().signal;
+  let opened;
+  let current;
+  let closing;
+  let devtoolsOpening;
+  let facet;
+  const openFacet = opts.devtools ?? openDevtools;
+  let attempt;
+  const session = {
+    env: resolved,
+    out,
+    results,
+    fixtures: opts.fixtures ?? defaultFixtures,
+    log: opts.log ?? writeLine,
+    get attempt() {
+      return attempt;
+    },
+    get signal() {
+      return attempt?.signal ?? idle;
+    },
+    get attemptDir() {
+      return attempt?.dir;
+    },
+    get trace() {
+      return attempt?.trace;
+    },
+    driver() {
+      if (closing !== undefined) {
+        return Promise.reject(new E2eError("SESSION", "session is closed"));
+      }
+      opened ??= factory(resolved).then((result) => {
+        if (!result.success) {
+          opened = undefined;
+          const { code, message } = result.error;
+          throw new E2eError("DRIVER", `${code}: ${message}`);
+        }
+        current = cacheObservations(traceDriver(result.data, { trace: () => attempt?.trace }));
+        return current;
+      }, (cause) => {
+        opened = undefined;
+        throw new E2eError("DRIVER", cause instanceof Error ? cause.message : String(cause));
+      });
+      return opened;
+    },
+    peekDriver() {
+      return current;
+    },
+    devtools() {
+      if (closing !== undefined)
+        return Promise.resolve(devtoolsErr("devtools_unavailable", "session is closed"));
+      if (resolved.metroUrl === undefined) {
+        return Promise.resolve(devtoolsErr("devtools_unavailable", "no Metro URL (WARDEN_METRO_URL): release builds have no devtools"));
+      }
+      if (devtoolsOpening !== undefined)
+        return devtoolsOpening;
+      const opening = openFacet(resolved).then((result) => {
+        if (!result.success) {
+          if (devtoolsOpening === opening)
+            devtoolsOpening = undefined;
+          return result;
+        }
+        const opened2 = result.data;
+        facet = opened2;
+        opened2.on("lost", () => {
+          if (facet !== opened2)
+            return;
+          facet = undefined;
+          if (devtoolsOpening === opening)
+            devtoolsOpening = undefined;
+          opened2.close();
+        });
+        return result;
+      }, (cause) => {
+        if (devtoolsOpening === opening)
+          devtoolsOpening = undefined;
+        return devtoolsErr("devtools_unavailable", cause instanceof Error ? cause.message : String(cause));
+      });
+      devtoolsOpening = opening;
+      return opening;
+    },
+    peekDevtools() {
+      return facet;
+    },
+    step(kind, label, fn) {
+      return runStep(attempt, kind, label, fn);
+    },
+    span(op, fn, options) {
+      return runSpan(attempt?.trace, op, fn, options);
+    },
+    enterAttempt(next, replacing) {
+      if (replacing !== undefined && attempt !== replacing)
+        return;
+      attempt = next;
+    },
+    leaveAttempt(leaving) {
+      if (leaving !== undefined && attempt !== leaving)
+        return;
+      attempt = undefined;
+    },
+    close() {
+      closing ??= (async () => {
+        if (opened !== undefined) {
+          await opened.then((d) => d.close(), () => {
+            return;
+          });
+        }
+        current = undefined;
+        if (devtoolsOpening !== undefined) {
+          await devtoolsOpening.then((result) => result.success ? result.data.close() : undefined, () => {
+            return;
+          });
+        }
+        facet = undefined;
+        if (slot()[SESSION_KEY] === session)
+          delete slot()[SESSION_KEY];
+        if (exitListener !== undefined)
+          process.off("exit", exitListener);
+      })();
+      return closing;
+    }
+  };
+  const exitListener = opts.exitHook === false ? undefined : () => {
+    session.close();
+  };
+  if (exitListener !== undefined)
+    process.on("exit", exitListener);
+  return session;
+}
+function attemptSession(session, binding) {
+  const context = () => binding().context;
+  const trace = () => binding().finished ? undefined : context().trace;
+  return {
+    get env() {
+      return session.env;
+    },
+    get out() {
+      return session.out;
+    },
+    get results() {
+      return session.results;
+    },
+    get fixtures() {
+      return session.fixtures;
+    },
+    set fixtures(factory) {
+      session.fixtures = factory;
+    },
+    get log() {
+      return session.log;
+    },
+    get attempt() {
+      return binding().finished ? undefined : context();
+    },
+    get signal() {
+      return context().signal;
+    },
+    get attemptDir() {
+      return context().dir;
+    },
+    get trace() {
+      return trace();
+    },
+    driver: () => session.driver(),
+    peekDriver: () => session.peekDriver(),
+    devtools: () => session.devtools(),
+    peekDevtools: () => session.peekDevtools(),
+    step(kind, label, fn) {
+      return runStep(context(), kind, label, fn);
+    },
+    span(op, fn, options) {
+      return runSpan(trace(), op, fn, options);
+    },
+    enterAttempt: (next, replacing) => session.enterAttempt(next, replacing),
+    leaveAttempt: (leaving) => session.leaveAttempt(leaving),
+    close: () => session.close()
+  };
+}
+function getSession(opts = {}) {
+  const existing = slot()[SESSION_KEY];
+  if (existing !== undefined)
+    return existing;
+  const session = createSession(opts);
+  slot()[SESSION_KEY] = session;
+  return session;
+}
+
+// ../../packages/e2e/src/runner/callsite.ts
+import { join as join2 } from "path";
+var OWN_FILES = new Set(["callsite.ts", "scope.ts", "test.ts", "attempt.ts"].map((name) => join2(import.meta.dir, name)).concat(join2(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_MS = 30000;
+function newScope(title, parent, serial) {
+  return { title, parent, use: {}, beforeEach: [], afterEach: [], serial };
+}
+var roots = new Map;
+var stack = [];
+function rootFor(file) {
+  let root = roots.get(file);
+  if (root === undefined) {
+    root = newScope([], undefined, false);
+    roots.set(file, root);
+  }
+  return root;
+}
+function currentScope() {
+  return stack[stack.length - 1] ?? rootFor(callerFile());
+}
+function createScope(title, serial) {
+  const parent = currentScope();
+  return newScope([...parent.title, title], parent, serial);
+}
+function runInScope(scope, body) {
+  stack.push(scope);
+  try {
+    body();
+  } finally {
+    stack.pop();
+  }
+}
+function scopeChain(scope) {
+  const chain = [];
+  for (let s = scope;s !== undefined; s = s.parent)
+    chain.unshift(s);
+  return chain;
+}
+function hooksFor(scope, kind) {
+  const chain = scopeChain(scope);
+  if (kind === "afterEach")
+    chain.reverse();
+  return chain.flatMap((s) => s[kind]);
+}
+function resolveUse(scope, defaults, testTimeout) {
+  const resolved = { ...defaults, launch: "fresh", systemAlerts: "off" };
+  for (const s of scopeChain(scope)) {
+    if (s.use.timeout !== undefined)
+      resolved.timeoutMs = s.use.timeout;
+    if (s.use.actionTimeout !== undefined)
+      resolved.actionTimeoutMs = s.use.actionTimeout;
+    if (s.use.assertionTimeout !== undefined)
+      resolved.assertionTimeoutMs = s.use.assertionTimeout;
+    if (s.use.launch !== undefined)
+      resolved.launch = s.use.launch;
+    if (s.use.systemAlerts !== undefined)
+      resolved.systemAlerts = s.use.systemAlerts;
+  }
+  if (testTimeout !== undefined)
+    resolved.timeoutMs = testTimeout;
+  return resolved;
+}
+function registrationDefaults(env = process.env) {
+  const read = readEnv(env);
+  const parsed = read.success ? read.data : undefined;
+  return {
+    timeoutMs: parsed?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    actionTimeoutMs: parsed?.actionTimeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS,
+    assertionTimeoutMs: parsed?.assertionTimeoutMs ?? DEFAULT_ASSERTION_TIMEOUT_MS,
+    platform: parsed?.platform
+  };
+}
+var ONLY_KEY = Symbol.for("@delacour/warden-e2e/only");
+function markOnly() {
+  globalThis[ONLY_KEY] = true;
+}
+function onlyWasSeen() {
+  return globalThis[ONLY_KEY] === true;
+}
+
+// ../../packages/e2e/src/version.ts
+var WORKSPACE_VERSION = "0.0.0-workspace";
+var WARDEN_E2E_VERSION = "0.1.1";
+
+// ../../packages/e2e/src/driver/settle.ts
+var isVia = (value) => value === "stream" || value === "snapshot" || value === "hash";
+function settleDetailOf(outcome) {
+  const reply = { ...outcome };
+  const { via, reason, frontmostPid } = reply;
+  return {
+    quiet: outcome.quiet,
+    waitedMs: outcome.waitedMs,
+    ...isVia(via) ? { via } : {},
+    ...typeof reason === "string" ? { reason } : {},
+    ...typeof frontmostPid === "number" ? { frontmostPid } : {}
+  };
+}
+var DEFAULT_SETTLE_QUIET_MS = 250;
+var DEFAULT_SETTLE_TIMEOUT_MS = 3000;
+var DEFAULT_POLL_MS2 = 50;
+async function settleByHash(poll, deps) {
+  const { quietMs, timeoutMs, now, sleep } = deps;
+  const pollMs = deps.pollMs ?? DEFAULT_POLL_MS2;
+  const start = now();
+  let previous = await poll();
+  let lastChange = now();
+  for (;; ) {
+    const elapsed = now() - start;
+    if (elapsed >= timeoutMs)
+      return { quiet: false, waitedMs: elapsed };
+    await sleep(Math.min(pollMs, Math.max(0, timeoutMs - elapsed)));
+    const hash = await poll();
+    const t = now();
+    if (hash !== previous) {
+      previous = hash;
+      lastChange = t;
+    } else if (t - lastChange >= quietMs) {
+      return { quiet: true, waitedMs: t - start };
+    }
+    if (t - start >= timeoutMs)
+      return { quiet: false, waitedMs: t - start };
+  }
+}
+function tuple(element) {
+  const { x, y, width, height } = element.frame;
+  return JSON.stringify([
+    element.role,
+    element.identifier ?? null,
+    element.label ?? null,
+    element.value ?? null,
+    Math.round(x),
+    Math.round(y),
+    Math.round(width),
+    Math.round(height)
+  ]);
+}
+function snapshotHash(snapshot) {
+  let text = "";
+  for (const element of snapshot.flat)
+    text += `${tuple(element)}
+`;
+  return Bun.hash(text).toString(36);
+}
+
+// ../../packages/e2e/src/driver/typing.ts
+var KEY_PACE_MS = 0;
+var SPLIT_TEXT = false;
+function canRepeatKeys(driver) {
+  return typeof driver.pressKeyRepeat === "function";
+}
+function canSelectAll(driver) {
+  return typeof driver.selectAll === "function";
+}
+function canSetText(driver) {
+  return typeof driver.setText === "function";
+}
+var segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+function graphemesOf(text) {
+  return Array.from(segmenter.segment(text), (part) => part.segment);
+}
+async function pace(driver, sleep) {
+  if (driver.platform === "ios" && KEY_PACE_MS > 0)
+    await sleep(KEY_PACE_MS);
+}
+async function typeText(driver, sleep, text) {
+  if (driver.platform !== "ios" || !SPLIT_TEXT) {
+    const typed = await driver.typeText(text);
+    if (typed.success)
+      await pace(driver, sleep);
+    return typed;
+  }
+  for (const character of graphemesOf(text)) {
+    const typed = await driver.typeText(character);
+    if (!typed.success)
+      return typed;
+    await pace(driver, sleep);
+  }
+  return ok(undefined);
+}
+async function pressKeys(driver, sleep, key, times) {
+  if (times > 1 && canRepeatKeys(driver))
+    return driver.pressKeyRepeat(key, times);
+  for (let press = 0;press < times; press += 1) {
+    const pressed = await driver.key(key);
+    if (!pressed.success)
+      return pressed;
+    await pace(driver, sleep);
+  }
+  return ok(undefined);
+}
+
+// ../../packages/e2e/src/screen/actions.ts
+var MOMENTUM = {
+  none: { fraction: 0.5, durationMs: 350, momentum: false },
+  slow: { fraction: 0.5, durationMs: 200, momentum: true },
+  fast: { fraction: 0.7, durationMs: 120, momentum: true }
+};
+var FOCUS_X = 0.9;
+var MAX_CLEAR_KEYS = 300;
+function tapPointOf(entry, position) {
+  const { frame, tapPoint } = entry.element;
+  if (position !== undefined)
+    return { x: frame.x + position.x, y: frame.y + position.y };
+  return tapPoint ?? { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 };
+}
+function focusPoint(frame) {
+  return { x: frame.x + frame.width * FOCUS_X, y: frame.y + frame.height / 2 };
+}
+function swipeVector(direction, rect, momentum = "none") {
+  const preset = MOMENTUM[momentum];
+  const options = { durationMs: preset.durationMs, momentum: preset.momentum };
+  return { ...contentPath(direction, rect, preset.fraction), options };
+}
+function contentPath(direction, rect, fraction) {
+  const centre = { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+  const halfX = rect.width * fraction / 2;
+  const halfY = rect.height * fraction / 2;
+  switch (direction) {
+    case "down":
+      return { from: { x: centre.x, y: centre.y + halfY }, to: { x: centre.x, y: centre.y - halfY } };
+    case "up":
+      return { from: { x: centre.x, y: centre.y - halfY }, to: { x: centre.x, y: centre.y + halfY } };
+    case "right":
+      return { from: { x: centre.x + halfX, y: centre.y }, to: { x: centre.x - halfX, y: centre.y } };
+    case "left":
+      return { from: { x: centre.x - halfX, y: centre.y }, to: { x: centre.x + halfX, y: centre.y } };
+  }
+}
+function screenRect(screen) {
+  return { x: 0, y: 0, width: screen.width, height: screen.height };
+}
+function visibleRect(frame, screen) {
+  if (screen.width <= 0 || screen.height <= 0)
+    return frame;
+  const left = Math.max(frame.x, 0);
+  const top = Math.max(frame.y, 0);
+  const right = Math.min(frame.x + frame.width, screen.width);
+  const bottom = Math.min(frame.y + frame.height, screen.height);
+  return { x: left, y: top, width: Math.max(0, right - left), height: Math.max(0, bottom - top) };
+}
+function isOnScreen(point, screen) {
+  if (screen.width <= 0 || screen.height <= 0)
+    return true;
+  return point.x >= 0 && point.y >= 0 && point.x <= screen.width && point.y <= screen.height;
+}
+function fieldValue(entry) {
+  if (entry.secure)
+    return "";
+  const { element } = entry;
+  const own = entry.value ?? (entry.role === "textbox" || entry.role === "searchbox" ? element.text : undefined);
+  if (own === undefined || own === "")
+    return "";
+  if (element.placeholder !== undefined && own === element.placeholder && entry.states.focused !== true)
+    return "";
+  return own;
+}
+var segmenter2 = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+function graphemes(text) {
+  let count = 0;
+  for (const _ of segmenter2.segment(text))
+    count += 1;
+  return count;
+}
+var SECURE_DOTS = new Set(["\u2022", "\u25CF"]);
+function countDots(value) {
+  let count = 0;
+  for (const part of segmenter2.segment(value))
+    if (SECURE_DOTS.has(part.segment))
+      count += 1;
+  return count;
+}
+function fieldContent(entry) {
+  if (entry.secure) {
+    const count = countDots(entry.element.value ?? "");
+    return count === 0 ? { kind: "empty" } : { kind: "dots", count };
+  }
+  const text = fieldValue(entry);
+  return text === "" ? { kind: "empty" } : { kind: "text", text };
+}
+function clearKeyPresses(entry) {
+  const content = fieldContent(entry);
+  switch (content.kind) {
+    case "empty":
+      return 0;
+    case "text":
+      return Math.min(graphemes(content.text) + 1, MAX_CLEAR_KEYS);
+    case "dots":
+      return Math.min(content.count + 1, MAX_CLEAR_KEYS);
+  }
+}
+var PINCH_MS = 500;
+var ROTATE_MS = 500;
+var PATH_MS = 600;
+var SCALE_RANGE = [0.1, 10];
+var MAX_ROTATE_DEGREES = 720;
+var REACH = 0.8;
+var MIN_RADIUS = 0.04;
+var ROTATE_SHARE = 0.3;
+function centreOf(rect) {
+  return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+}
+function pinchRadius(rect, scale2, screen) {
+  const reach = Math.min(rect.width, rect.height) / 2 * REACH;
+  const floor = MIN_RADIUS * Math.min(screen.width, screen.height);
+  return Math.max(reach / Math.max(1, scale2), floor / Math.min(1, scale2));
+}
+function rotateRadius(rect, screen) {
+  const side = Math.min(screen.width, screen.height);
+  return Math.min(Math.max(Math.min(rect.width, rect.height) * ROTATE_SHARE, MIN_RADIUS * side), ROTATE_SHARE * side);
+}
+function requireGesture(driver, cap, verb, fingers = 1) {
+  const { capabilities, platform } = driver;
+  if (cap === "pinch" ? capabilities.pinch : capabilities.maxPointers >= fingers)
+    return;
+  const detail = cap === "pinch" ? "capabilities.pinch is false" : `capabilities.maxPointers is ${capabilities.maxPointers}, needs ${fingers}`;
+  throw new E2eError("INVALID_ARGUMENT", `${verb} is not supported on ${platform} (driver capability: ${detail}); use test({ platforms: [...] }) to skip`);
+}
+function assertScale(scale2) {
+  if (!Number.isFinite(scale2) || scale2 < SCALE_RANGE[0] || scale2 > SCALE_RANGE[1] || scale2 === 1) {
+    throw new E2eError("INVALID_ARGUMENT", `pinch scale must be a finite number from ${SCALE_RANGE[0]} to ${SCALE_RANGE[1]} and not 1, got ${scale2}`);
+  }
+}
+function assertDegrees(degrees) {
+  if (!Number.isFinite(degrees) || degrees === 0 || Math.abs(degrees) > MAX_ROTATE_DEGREES) {
+    throw new E2eError("INVALID_ARGUMENT", `rotate degrees must be finite, not 0 and at most ${MAX_ROTATE_DEGREES} either way, got ${degrees}`);
+  }
+}
+
+// ../../packages/e2e/src/screen/roles.ts
+var QUERY_ROLES = [
+  "button",
+  "link",
+  "textbox",
+  "searchbox",
+  "checkbox",
+  "radio",
+  "switch",
+  "slider",
+  "image",
+  "heading",
+  "text",
+  "tab",
+  "tablist",
+  "menu",
+  "menuitem",
+  "list",
+  "listitem",
+  "row",
+  "alert",
+  "dialog",
+  "navigation",
+  "group",
+  "other"
+];
+var QUERY_ROLE_SET = new Set(QUERY_ROLES);
+function isQueryRole(value) {
+  return QUERY_ROLE_SET.has(value);
+}
+var INTERACTIVE_ROLES = new Set([
+  "button",
+  "link",
+  "textbox",
+  "searchbox",
+  "checkbox",
+  "radio",
+  "switch",
+  "slider",
+  "tab",
+  "menuitem"
+]);
+function isInteractiveRole(role) {
+  return INTERACTIVE_ROLES.has(role);
+}
+var DRIVER_ROLE_MAP = {
+  button: "button",
+  text: "text",
+  textfield: "textbox",
+  securefield: "textbox",
+  searchfield: "searchbox",
+  image: "image",
+  switch: "switch",
+  checkbox: "checkbox",
+  slider: "slider",
+  link: "link",
+  cell: "listitem",
+  list: "list",
+  scrollview: "group",
+  tab: "tab",
+  tabbar: "tablist",
+  alert: "alert",
+  sheet: "dialog",
+  keyboard: "other",
+  navbar: "navigation",
+  toolbar: "group",
+  window: "other",
+  application: "other",
+  other: "other"
+};
+var SPELLED_ROLES = {
+  alert: "alert",
+  checkbox: "checkbox",
+  "combo box": "other",
+  menu: "menu",
+  "menu bar": "menu",
+  "menu item": "menuitem",
+  "progress bar": "other",
+  "radio button": "radio",
+  "radio group": "group",
+  "scroll bar": "other",
+  "spin button": "other",
+  switch: "switch",
+  tab: "tab",
+  "tab list": "tablist",
+  timer: "other",
+  "tool bar": "group"
+};
+var SPELLED_STATES = {
+  checked: { checked: true },
+  unchecked: { checked: false },
+  expanded: { expanded: true },
+  collapsed: { expanded: false }
+};
+var SPELLED_LOOSE_WORDS = new Set(["mixed", "busy"]);
+function parseSpelledValue(value) {
+  if (value === undefined)
+    return;
+  const parts = value.split(", ");
+  const role = SPELLED_ROLES[parts[0]?.toLowerCase() ?? ""];
+  if (role === undefined)
+    return;
+  const states = {};
+  const rest = [];
+  let position = 1;
+  for (;position < parts.length; position += 1) {
+    const part = parts[position] ?? "";
+    const word = part.toLowerCase();
+    const state = SPELLED_STATES[word];
+    if (state !== undefined) {
+      Object.assign(states, state);
+      continue;
+    }
+    if (SPELLED_LOOSE_WORDS.has(word)) {
+      rest.push(part);
+      continue;
+    }
+    break;
+  }
+  rest.push(...parts.slice(position));
+  return { ...states, role, value: rest.length === 0 ? undefined : rest.join(", ") };
+}
+var ANDROID_ROLE_MAP = {
+  "text-view": "text",
+  "edit-text": "textbox",
+  "auto-complete-text-view": "textbox",
+  "text-input-edit-text": "textbox",
+  "search-view": "searchbox",
+  button: "button",
+  "image-button": "button",
+  "material-button": "button",
+  "image-view": "image",
+  switch: "switch",
+  "switch-compat": "switch",
+  "switch-material": "switch",
+  "toggle-button": "switch",
+  "check-box": "checkbox",
+  "material-check-box": "checkbox",
+  "radio-button": "radio",
+  "seek-bar": "slider",
+  slider: "slider",
+  "tab-layout": "tablist",
+  "tab-widget": "tablist",
+  "bottom-navigation-view": "tablist",
+  "recycler-view": "list",
+  "list-view": "list",
+  "abs-list-view": "list",
+  "grid-view": "list",
+  "scroll-view": "group",
+  "horizontal-scroll-view": "group",
+  "view-group": "group",
+  view: "group",
+  "compose-view": "group",
+  "view-factory-holder": "group",
+  "card-view": "group"
+};
+var ANDROID_GENERIC_CONTAINERS = new Set([
+  "view-group",
+  "view",
+  "compose-view",
+  "view-factory-holder",
+  "card-view"
+]);
+function kebabSimpleName(rawType) {
+  const simple = rawType.slice(rawType.lastIndexOf(".") + 1);
+  return simple.replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").replaceAll(/[\s_$]+/g, "-").toLowerCase();
+}
+function isAndroidClass(rawType) {
+  return rawType.includes(".");
+}
+function upgradeByTraits(role, traits) {
+  if (role !== "other" && role !== "group" && role !== "text")
+    return role;
+  if (traits.has("header") || traits.has("heading"))
+    return "heading";
+  if (role === "text" && !traits.has("link") && !traits.has("button"))
+    return role;
+  if (traits.has("link"))
+    return "link";
+  if (traits.has("button"))
+    return "button";
+  if (role === "text")
+    return role;
+  if (traits.has("image"))
+    return "image";
+  if (traits.has("adjustable"))
+    return "slider";
+  if (traits.has("searchfield"))
+    return "searchbox";
+  return role;
+}
+function resolveAndroid(element, traits) {
+  const kind = kebabSimpleName(element.rawType);
+  const mapped = ANDROID_ROLE_MAP[kind];
+  const isLayout = kind.endsWith("layout");
+  const driverRole = DRIVER_ROLE_MAP[element.role];
+  const role = mapped ?? (isLayout && driverRole === "other" ? "group" : driverRole);
+  const container = role === "group" || role === "other";
+  if (traits.has("heading") && (container || role === "text"))
+    return "heading";
+  const promotable = container && (mapped === undefined || isLayout || ANDROID_GENERIC_CONTAINERS.has(kind));
+  if (!promotable)
+    return role;
+  if (traits.has("checkable"))
+    return "checkbox";
+  return traits.has("clickable") ? "button" : role;
+}
+function resolveRole(element, parent) {
+  const traits = new Set(element.traits.map((trait) => trait.toLowerCase()));
+  if (isAndroidClass(element.rawType))
+    return { role: resolveAndroid(element, traits) };
+  if (element.role === "other") {
+    const spelled = parseSpelledValue(element.value);
+    if (spelled !== undefined)
+      return { role: spelled.role, spelled };
+  }
+  if (element.role === "button" && parent?.role === "tabbar")
+    return { role: "tab" };
+  return { role: upgradeByTraits(DRIVER_ROLE_MAP[element.role], traits) };
+}
+
+// ../../packages/e2e/src/screen/text.ts
+function normalizeText(text) {
+  return text.replaceAll(/\s+/g, " ").trim();
+}
+function matchesText(value, match, options = {}) {
+  const normalized = normalizeText(value);
+  if (typeof match !== "string") {
+    const flags = match.flags.replaceAll(/[gy]/g, "");
+    return new RegExp(match.source, flags).test(normalized);
+  }
+  const wanted = normalizeText(match);
+  if (options.exact === false)
+    return normalized.toLowerCase().includes(wanted.toLowerCase());
+  return normalized === wanted;
+}
+
+// ../../packages/e2e/src/screen/nodes.ts
+var CHECKABLE_ROLES = new Set(["switch", "checkbox", "radio"]);
+var CHECKED_WORDS = new Set(["1", "on", "true", "checked"]);
+var UNCHECKED_WORDS = new Set(["0", "off", "false", "unchecked"]);
+function nonEmpty(value) {
+  return value === undefined || value === "" ? undefined : value;
+}
+function isSecure(element, traits) {
+  return element.role === "securefield" || traits.has("password") || traits.has("secure") || element.rawType.toLowerCase().includes("secure");
+}
+function deriveChecked(element, role, spelled, traits, value) {
+  if (spelled?.checked !== undefined)
+    return spelled.checked;
+  if (element.checked !== undefined)
+    return element.checked;
+  if (traits.has("checkable"))
+    return traits.has("checked");
+  if (CHECKABLE_ROLES.has(role) && value !== undefined) {
+    const word = value.trim().toLowerCase();
+    if (CHECKED_WORDS.has(word))
+      return true;
+    if (UNCHECKED_WORDS.has(word))
+      return false;
+  }
+  return;
+}
+function intersectsScreen(frame, screen) {
+  if (frame.width <= 0 || frame.height <= 0)
+    return false;
+  if (screen.width <= 0 || screen.height <= 0)
+    return true;
+  return frame.x < screen.width && frame.y < screen.height && frame.x + frame.width > 0 && frame.y + frame.height > 0;
+}
+function ownFragments(name, element, value) {
+  const seen = new Set;
+  for (const raw of [element.label, element.text, value]) {
+    const text = raw === undefined ? "" : normalizeText(raw);
+    if (text !== "")
+      seen.add(text);
+  }
+  if (name !== undefined && normalizeText(name) !== "")
+    seen.add(normalizeText(name));
+  return [...seen];
+}
+function subtreeFragments(entry) {
+  const below = entry.children.flatMap((child) => child.fragments);
+  const belowText = below.join(" ");
+  const own = ownFragments(entry.name, entry.element, entry.value).filter((text) => text !== belowText && !below.includes(text));
+  return [...own, ...below];
+}
+function indexSnapshot(snapshot) {
+  const entries = [];
+  const byId = new Map;
+  const build = (element, depth, parent) => {
+    const traits = new Set(element.traits.map((trait) => trait.toLowerCase()));
+    const { role, spelled } = resolveRole(element, parent?.element);
+    const secure = isSecure(element, traits);
+    const rawValue = spelled === undefined ? element.value : spelled.value;
+    const value = secure ? undefined : nonEmpty(rawValue);
+    const name = nonEmpty(element.label) ?? nonEmpty(element.text);
+    const hidden = element.hidden === true || parent?.states.hidden === true;
+    let fragments;
+    let subtreeText;
+    const entry = {
+      position: entries.length,
+      element,
+      depth,
+      parent,
+      children: [],
+      role,
+      name,
+      value,
+      states: {
+        checked: deriveChecked(element, role, spelled, traits, value),
+        expanded: spelled?.expanded,
+        disabled: !element.enabled,
+        selected: element.selected === true,
+        focused: element.focused === true,
+        hidden
+      },
+      secure,
+      visible: !hidden && intersectsScreen(element.frame, snapshot.screen),
+      get fragments() {
+        fragments ??= subtreeFragments(entry);
+        return fragments;
+      },
+      get subtreeText() {
+        subtreeText ??= entry.fragments.join(" ");
+        return subtreeText;
+      }
+    };
+    entries.push(entry);
+    byId.set(element.id, entry);
+    for (const child of element.children)
+      entry.children.push(build(child, depth + 1, entry));
+    return entry;
+  };
+  for (const element of snapshot.elements)
+    build(element, 0, undefined);
+  return { entries, byId, screen: snapshot.screen };
+}
+function isWithin(entry, ancestor) {
+  for (let current = entry.parent;current !== undefined; current = current.parent) {
+    if (current === ancestor)
+      return true;
+  }
+  return false;
+}
+function descendantsOf(universe, ancestors) {
+  if (ancestors.length === 0)
+    return [];
+  const wanted = new Set(ancestors);
+  return universe.filter((entry) => {
+    for (let current = entry.parent;current !== undefined; current = current.parent) {
+      if (wanted.has(current))
+        return true;
+    }
+    return false;
+  });
+}
+function entryOfElement(element, template) {
+  const flat = [];
+  const walk = (e) => {
+    flat.push(e);
+    for (const child of e.children)
+      walk(child);
+  };
+  walk(element);
+  const index = indexSnapshot({
+    platform: template.platform,
+    backend: "axbridge",
+    takenAt: 0,
+    screen: { width: 0, height: 0, scale: 1 },
+    elements: [element],
+    flat,
+    truncated: false
+  });
+  return index.entries[0];
+}
+
+// ../../packages/e2e/src/screen/field.ts
+var FIELD_POLL_MS = 50;
+var FIELD_PROGRESS_MS = 1000;
+var CONFIRM_READS = 2;
+var STALE_RISK_READS = 4;
+function confirmReadsFor(entry, text) {
+  if (entry === undefined || text === "")
+    return CONFIRM_READS;
+  return fieldValue(entry) === text ? STALE_RISK_READS : CONFIRM_READS;
+}
+async function confirmFieldValue(request) {
+  const { now, sleep } = request;
+  const start = now();
+  const cap = request.maxMs === undefined ? Number.POSITIVE_INFINITY : start + request.maxMs;
+  let deadline = Math.min(start + request.budgetMs, cap);
+  let held = "(gone)";
+  let streak = 0;
+  for (;; ) {
+    const read = await request.read();
+    if (!read.ok)
+      return { status: "failed", error: read.error };
+    const { reading } = read;
+    if (reading.kind === "unreadable") {
+      streak = 0;
+      held = reading.note;
+    } else if (reading.value === request.text) {
+      streak += 1;
+      if (streak >= (request.reads ?? CONFIRM_READS))
+        return { status: "confirmed" };
+      held = reading.value;
+      deadline = Math.max(deadline, Math.min(now() + 2 * FIELD_POLL_MS, cap));
+    } else {
+      streak = 0;
+      if (reading.value !== held)
+        deadline = Math.max(deadline, Math.min(now() + FIELD_PROGRESS_MS, cap));
+      held = reading.value;
+    }
+    if (now() >= deadline)
+      return { status: "mismatch", held };
+    await sleep(FIELD_POLL_MS);
+  }
+}
+async function hitTestField(driver, wanted) {
+  const { x, y, width, height } = wanted.element.frame;
+  const hit = await driver.elementAtPoint({ x: x + width / 2, y: y + height / 2 });
+  if (!hit.success)
+    return { ok: false, error: hit.error };
+  if (!hit.data)
+    return { ok: true, entry: undefined };
+  const entry = entryOfElement(hit.data, { platform: driver.platform });
+  return { ok: true, entry: entry?.role === wanted.role ? entry : undefined };
+}
+var FOCUS_POLL_MS = 20;
+var FOCUS_POLLS = 25;
+function isSameField(hit, entry) {
+  const identifier = entry.element.identifier;
+  return hit.role === entry.element.role && (identifier === undefined || hit.identifier === identifier);
+}
+async function tapToFocus(driver, sleep, point, entry) {
+  const tapped = await driver.tap(point);
+  if (!tapped.success || driver.platform !== "ios" || entry === undefined || entry.states.focused === true)
+    return tapped;
+  for (let poll = 1;poll <= FOCUS_POLLS; poll += 1) {
+    const hit = await driver.elementAtPoint(point);
+    if (!hit.success || !hit.data || !isSameField(hit.data, entry) || hit.data.focused === true)
+      break;
+    if (poll < FOCUS_POLLS)
+      await sleep(FOCUS_POLL_MS);
+  }
+  return ok(undefined);
+}
+var SETTEXT_ENV = "WARDEN_ANDROID_SETTEXT";
+function setTextOptedIn(env) {
+  return env[SETTEXT_ENV] === "1";
+}
+async function focusAndSelect(driver, sleep, point, entry, method) {
+  const focused = await tapToFocus(driver, sleep, point, entry);
+  if (!focused.success)
+    return focused;
+  return prepareFocused(driver, sleep, entry, method);
+}
+async function prepareFocused(driver, sleep, entry, method) {
+  if (entry === undefined)
+    return ok({ pending: "none" });
+  const content = fieldContent(entry);
+  if (content.kind === "empty")
+    return ok({ pending: "none" });
+  if (content.kind === "text" && method !== "counted" && canSelectAll(driver)) {
+    const selected = await driver.selectAll();
+    if (selected.success)
+      return ok({ pending: "selection" });
+  }
+  const pressed = await pressKeys(driver, sleep, "Backspace", clearKeyPresses(entry));
+  return pressed.success ? ok({ pending: "none" }) : pressed;
+}
+async function focusAndClear(driver, sleep, point, entry, method = "auto") {
+  const prepared = await focusAndSelect(driver, sleep, point, entry, method);
+  if (!prepared.success)
+    return prepared;
+  return prepared.data.pending === "selection" ? pressKeys(driver, sleep, "Backspace", 1) : ok(undefined);
+}
+async function focusClearType(driver, sleep, point, entry, text, method = "auto", env = process.env) {
+  const wantsSetText = method === "setText" || method === "auto" && setTextOptedIn(env);
+  if (wantsSetText && entry !== undefined && fieldContent(entry).kind === "text" && canSetText(driver)) {
+    const focused = await driver.tap(point);
+    if (!focused.success)
+      return focused;
+    const replaced = await driver.setText(text);
+    if (replaced.success)
+      return replaced;
+    return typeOver(driver, sleep, await prepareFocused(driver, sleep, entry, method), text);
+  }
+  return typeOver(driver, sleep, await focusAndSelect(driver, sleep, point, entry, method), text);
+}
+async function typeOver(driver, sleep, prepared, text) {
+  if (!prepared.success)
+    return prepared;
+  if (text === "")
+    return prepared.data.pending === "selection" ? pressKeys(driver, sleep, "Backspace", 1) : ok(undefined);
+  return typeText(driver, sleep, text);
+}
+
+// ../../packages/e2e/src/screen/selector.ts
+var VALUE_KEYS = ["id", "label", "text", "role", "value"];
+var KEY_ORDER = [...VALUE_KEYS, "editable", "nth"];
+var REGEX_FLAGS = /^[dgimsuvy]*$/;
+function isSpace(char) {
+  return char === undefined || /\s/.test(char);
+}
+function readQuoted(input, start) {
+  let end = start + 1;
+  while (end < input.length && input[end] !== '"')
+    end += input[end] === "\\" ? 2 : 1;
+  if (end >= input.length)
+    return err("unterminated quoted value");
+  const literal = input.slice(start, end + 1);
+  try {
+    const value = JSON.parse(literal);
+    if (typeof value !== "string")
+      return err(`invalid escape in ${literal}`);
+    return ok({ value, end: end + 1 });
+  } catch {
+    return err(`invalid escape in ${literal}`);
+  }
+}
+function readRegex(input, start) {
+  let end = start + 1;
+  while (end < input.length && input[end] !== "/")
+    end += input[end] === "\\" ? 2 : 1;
+  if (end >= input.length)
+    return err("unterminated regex value");
+  const source = input.slice(start + 1, end);
+  if (source === "")
+    return err("empty regex //");
+  let flagsEnd = end + 1;
+  while (flagsEnd < input.length && !isSpace(input[flagsEnd]))
+    flagsEnd += 1;
+  const flags = input.slice(end + 1, flagsEnd);
+  try {
+    if (!REGEX_FLAGS.test(flags))
+      throw new Error("bad flags");
+    new RegExp(source, flags);
+  } catch {
+    return err(`invalid regex /${source}/${flags}`);
+  }
+  return ok({ value: { kind: "regex", source, flags }, end: flagsEnd });
+}
+function readValue(input, start, key) {
+  const first = input[start];
+  if (isSpace(first))
+    return err(`missing value for ${key}=`);
+  if (first === '"') {
+    const quoted = readQuoted(input, start);
+    if (!quoted.success)
+      return quoted;
+    if (!isSpace(input[quoted.data.end]))
+      return err(`unexpected text after quoted value of ${key}=`);
+    return ok({ value: { kind: "text", value: quoted.data.value }, end: quoted.data.end });
+  }
+  if (first === "/")
+    return readRegex(input, start);
+  let end = start;
+  while (!isSpace(input[end]))
+    end += 1;
+  return ok({ value: { kind: "text", value: input.slice(start, end) }, end });
+}
+function tokenize(input) {
+  const tokens = [];
+  let position = 0;
+  for (;; ) {
+    while (position < input.length && isSpace(input[position]))
+      position += 1;
+    if (position >= input.length)
+      return ok(tokens);
+    const equals = input.indexOf("=", position);
+    let wordEnd = position;
+    while (!isSpace(input[wordEnd]))
+      wordEnd += 1;
+    if (equals === -1 || equals > wordEnd)
+      return err(`expected key=value, got "${input.slice(position, wordEnd)}"`);
+    const key = input.slice(position, equals);
+    const read = readValue(input, equals + 1, key);
+    if (!read.success)
+      return read;
+    tokens.push({ key, raw: input.slice(position, read.data.end), value: read.data.value });
+    position = read.data.end;
+  }
+}
+function isSelectorKey(key) {
+  return KEY_ORDER.includes(key);
+}
+function isValueKey(key) {
+  return VALUE_KEYS.includes(key);
+}
+function parseSelector(input) {
+  if (input.trim() === "")
+    return err("empty selector");
+  const tokens = tokenize(input);
+  if (!tokens.success)
+    return tokens;
+  const selector = {};
+  const seen = new Set;
+  for (const token of tokens.data) {
+    if (!isSelectorKey(token.key)) {
+      return err(`unknown key "${token.key}" (expected ${KEY_ORDER.join(", ")})`);
+    }
+    if (seen.has(token.key))
+      return err(`duplicate key "${token.key}"`);
+    seen.add(token.key);
+    const failure = applyToken(selector, token.key, token);
+    if (failure !== undefined)
+      return err(failure);
+  }
+  return ok(selector);
+}
+function applyToken(selector, key, token) {
+  if (isValueKey(key)) {
+    selector[key] = token.value;
+    return;
+  }
+  const word = token.value.kind === "text" ? token.value.value : "";
+  if (key === "editable") {
+    if (word !== "true" && word !== "false")
+      return `editable must be true or false, got ${token.raw}`;
+    selector.editable = word === "true";
+    return;
+  }
+  if (!/^\d+$/.test(word))
+    return `nth must be a non-negative integer, got ${token.raw}`;
+  selector.nth = Number(word);
+  return;
+}
+function formatValue2(value) {
+  if (value.kind === "regex")
+    return `/${value.source}/${value.flags}`;
+  return /^[^\s"/][^\s]*$/.test(value.value) ? value.value : JSON.stringify(value.value);
+}
+function formatSelector(selector) {
+  const parts = [];
+  for (const key of VALUE_KEYS) {
+    const value = selector[key];
+    if (value !== undefined)
+      parts.push(`${key}=${formatValue2(value)}`);
+  }
+  if (selector.editable !== undefined)
+    parts.push(`editable=${selector.editable}`);
+  if (selector.nth !== undefined)
+    parts.push(`nth=${selector.nth}`);
+  return parts.join(" ");
+}
+function selectorToQuery(selector) {
+  const { nth, ...rest } = selector;
+  const base = { kind: "query", query: { kind: "selector", selector: rest } };
+  return nth === undefined ? base : { kind: "index", source: base, index: nth };
+}
+function matchesValue(actual, value, mode) {
+  if (actual === undefined)
+    return false;
+  if (value.kind === "regex")
+    return matchesText(actual, new RegExp(value.source, value.flags));
+  if (mode === "exact")
+    return actual === value.value;
+  return matchesText(actual, value.value, { exact: false });
+}
+function kebabType(rawType) {
+  const simple = rawType.slice(rawType.lastIndexOf(".") + 1);
+  return simple.replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").replaceAll(/[\s_]+/g, "-").toLowerCase();
+}
+function roleNames(entry) {
+  return [entry.role, entry.element.role, kebabType(entry.element.rawType), entry.element.rawType.toLowerCase()];
+}
+function matchesRole(entry, value) {
+  const names = roleNames(entry);
+  if (value.kind === "regex")
+    return names.some((name) => matchesValue(name, value, "exact"));
+  const wanted = value.value.toLowerCase().replaceAll(/[\s_]+/g, "-");
+  return names.some((name) => name === wanted || name.replaceAll("-", "") === wanted.replaceAll("-", ""));
+}
+function textCandidates(entry) {
+  return [entry.element.label, entry.element.text, entry.value];
+}
+function matchesSelector(entry, selector) {
+  if (selector.id !== undefined && !matchesValue(entry.element.identifier, selector.id, "exact"))
+    return false;
+  if (selector.label !== undefined && !matchesValue(entry.name, selector.label, "substring"))
+    return false;
+  if (selector.text !== undefined) {
+    const wanted = selector.text;
+    if (!textCandidates(entry).some((candidate) => matchesValue(candidate, wanted, "substring")))
+      return false;
+  }
+  if (selector.value !== undefined && !matchesValue(entry.value, selector.value, "substring"))
+    return false;
+  if (selector.role !== undefined && !matchesRole(entry, selector.role))
+    return false;
+  if (selector.editable !== undefined) {
+    const editable = entry.role === "textbox" || entry.role === "searchbox";
+    if (editable !== selector.editable)
+      return false;
+  }
+  return true;
+}
+
+// ../../packages/e2e/src/screen/queries.ts
+var TEXT_KEYS = ["exact", "visible"];
+var TEST_ID_KEYS = ["visible"];
+var ROLE_KEYS = ["name", "exact", "checked", "disabled", "selected", "visible"];
+function assertKeys(method, options, allowed) {
+  const unknown = Object.keys(options).filter((key) => !allowed.includes(key));
+  if (unknown.length > 0) {
+    throw new E2eError("INVALID_LOCATOR", `${method} does not take ${unknown.map((key) => `"${key}"`).join(", ")}; it takes ${allowed.join(", ")}`);
+  }
+}
+function defined2(source) {
+  return Object.fromEntries(Object.entries(source).filter(([, value]) => value !== undefined));
+}
+function testIdQuery(id, options = {}) {
+  assertKeys("getByTestId", options, TEST_ID_KEYS);
+  return { kind: "testId", value: id, ...defined2(options) };
+}
+var METHOD = {
+  text: "getByText",
+  label: "getByLabel",
+  placeholder: "getByPlaceholder",
+  value: "getByValue"
+};
+function textQuery(kind, value, options = {}) {
+  assertKeys(METHOD[kind], options, TEXT_KEYS);
+  return { kind, value, ...defined2(options) };
+}
+function isRoleOptions(value) {
+  return value !== undefined && typeof value === "object" && !(value instanceof RegExp);
+}
+function roleQuery(role, nameOrOptions, options = {}) {
+  if (!isQueryRole(role)) {
+    throw new E2eError("INVALID_LOCATOR", `getByRole does not know the role "${String(role)}"; use one of ${QUERY_ROLES.join(", ")}`);
+  }
+  const merged = isRoleOptions(nameOrOptions) ? { ...nameOrOptions, ...options } : { ...nameOrOptions === undefined ? {} : { name: nameOrOptions }, ...options };
+  assertKeys("getByRole", merged, ROLE_KEYS);
+  return { kind: "role", role, ...defined2(merged) };
+}
+function selectorExpression(text) {
+  const parsed = parseSelector(text);
+  if (!parsed.success)
+    throw new E2eError("INVALID_LOCATOR", `invalid selector ${JSON.stringify(text)}: ${parsed.error}`);
+  return selectorToQuery(parsed.data);
+}
+function withScope(expr, scope) {
+  switch (expr.kind) {
+    case "query":
+      return {
+        kind: "query",
+        query: expr.query,
+        scope: expr.scope === undefined ? scope : withScope(expr.scope, scope)
+      };
+    case "filter":
+      return { ...expr, source: withScope(expr.source, scope) };
+    case "index":
+      return { ...expr, source: withScope(expr.source, scope) };
+  }
+}
+
+// ../../packages/e2e/src/screen/render.ts
+var MAX_NAME = 80;
+var MAX_VALUE = 60;
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function quote(text, max) {
+  return JSON.stringify(truncate(text, max));
+}
+function identifierToken(id) {
+  return /^[^\s"]+$/.test(id) ? id : JSON.stringify(id);
+}
+function stateWords(entry) {
+  const { states, element } = entry;
+  const words = [states.disabled ? "disabled" : "enabled"];
+  if (element.hittable === true)
+    words.push("hittable");
+  if (states.checked !== undefined)
+    words.push(states.checked ? "checked" : "unchecked");
+  if (states.selected)
+    words.push("selected");
+  if (states.focused)
+    words.push("focused");
+  if (entry.secure)
+    words.push("secure");
+  if (states.hidden)
+    words.push("hidden");
+  if (states.expanded !== undefined)
+    words.push(states.expanded ? "expanded" : "collapsed");
+  return words;
+}
+function head(entry) {
+  const parts = [`[${entry.role}]`];
+  if (entry.name !== undefined)
+    parts.push(quote(entry.name, MAX_NAME));
+  const id = entry.element.identifier;
+  if (id !== undefined && id !== "")
+    parts.push(`id=${identifierToken(id)}`);
+  return parts;
+}
+function describeEntry(entry) {
+  return head(entry).join(" ");
+}
+function renderEntryLine(entry, options = {}) {
+  const parts = [];
+  if (options.ref !== undefined)
+    parts.push(options.ref);
+  parts.push(...head(entry));
+  if (entry.value !== undefined)
+    parts.push(`value=${quote(entry.value, MAX_VALUE)}`);
+  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)})`);
+  return `${"  ".repeat(options.indent ?? 0)}${parts.join(" ")}`;
+}
+function isListed(entry) {
+  if (entry.states.hidden)
+    return false;
+  const id = entry.element.identifier;
+  return isInteractiveRole(entry.role) || id !== undefined && id !== "";
+}
+function renderSnapshot(snapshot, options) {
+  const index = indexSnapshot(snapshot);
+  const listed = options.interactiveOnly ? index.entries.filter(isListed) : index.entries;
+  const limit = options.maxLines === undefined ? listed.length : Math.max(0, options.maxLines);
+  const visible = listed.slice(0, limit);
+  const lines = visible.map((entry) => renderEntryLine(entry, {
+    indent: options.interactiveOnly ? 0 : entry.depth,
+    ...options.refs.has(entry.element.id) ? { ref: options.refs.get(entry.element.id) } : {}
+  }));
+  const omitted = listed.length - visible.length;
+  if (omitted > 0)
+    lines.push(`\u2026 ${omitted} more (use --all)`);
+  return { lines, shown: visible.length, total: index.entries.length, omitted };
+}
+function renderHeader(input) {
+  const { snapshot, rendered } = input;
+  const { width, height, scale: scale2 } = snapshot.screen;
+  if (input.style === "cli") {
+    const count = rendered.shown === rendered.total ? `${rendered.total}` : `${rendered.shown} of ${rendered.total}`;
+    const parts2 = [
+      ...input.generation === undefined ? [] : [`generation ${input.generation}`],
+      snapshot.backend,
+      `${width}\xD7${height}@${scale2}x`,
+      `${count} elements`
+    ];
+    return parts2.join(" \xB7 ") + (snapshot.truncated ? ", truncated" : "");
+  }
+  const parts = [`# ${snapshot.platform} ${snapshot.backend} ${width}\xD7${height}@${scale2}x`];
+  if (input.generation !== undefined)
+    parts.push(`gen ${input.generation}`);
+  let line = parts.join(" ");
+  line += ` \xB7 ${rendered.shown} of ${rendered.total} elements (${input.interactiveOnly ? "interactive" : "all"})`;
+  if (snapshot.truncated)
+    line += " \xB7 truncated by backend";
+  if (snapshot.modal !== undefined)
+    line += " \xB7 modal present";
+  return line;
+}
+
+// ../../packages/e2e/src/screen/query.ts
+function textOptions(exact) {
+  return { exact: exact ?? true };
+}
+function matchesQuery(entry, query) {
+  if (query.kind === "role")
+    return matchesRoleQuery(entry, query);
+  if (query.visible === true && entry.states.hidden)
+    return false;
+  switch (query.kind) {
+    case "testId": {
+      const id = entry.element.identifier;
+      return id !== undefined && id !== "" && matchesText(id, query.value);
+    }
+    case "text": {
+      const options = textOptions(query.exact);
+      return [entry.element.label, entry.element.text].some((text) => text !== undefined && text !== "" && matchesText(text, query.value, options));
+    }
+    case "label":
+      return entry.name !== undefined && matchesText(entry.name, query.value, textOptions(query.exact));
+    case "placeholder": {
+      const placeholder = entry.element.placeholder;
+      return placeholder !== undefined && matchesText(placeholder, query.value, textOptions(query.exact));
+    }
+    case "value":
+      return entry.value !== undefined && matchesText(entry.value, query.value, textOptions(query.exact));
+    case "selector":
+      return matchesSelector(entry, query.selector);
+  }
+}
+function matchesRoleQuery(entry, query) {
+  if (entry.role !== query.role || entry.states.hidden)
+    return false;
+  if (query.name !== undefined && !matchesText(entry.name ?? "", query.name, textOptions(query.exact)))
+    return false;
+  if (query.checked !== undefined && (entry.states.checked ?? false) !== query.checked)
+    return false;
+  if (query.disabled !== undefined && entry.states.disabled !== query.disabled)
+    return false;
+  if (query.selected !== undefined && entry.states.selected !== query.selected)
+    return false;
+  return true;
+}
+var ECHOED_KINDS = new Set(["text", "label"]);
+function innermostOnly(matches) {
+  const matched = new Set(matches);
+  return matches.filter((entry) => {
+    for (const other of matched) {
+      if (other !== entry && isWithin(other, entry))
+        return false;
+    }
+    return true;
+  });
+}
+function subtreeHasText(entry, hasText) {
+  const options = { exact: false };
+  return entry.fragments.some((fragment) => matchesText(fragment, hasText, options)) || matchesText(entry.subtreeText, hasText, options);
+}
+function evaluate(expr, universe) {
+  switch (expr.kind) {
+    case "query": {
+      const candidates = expr.scope === undefined ? universe : descendantsOf(universe, evaluate(expr.scope, universe));
+      const matches = candidates.filter((entry) => matchesQuery(entry, expr.query));
+      return ECHOED_KINDS.has(expr.query.kind) ? innermostOnly(matches) : matches;
+    }
+    case "filter":
+      return evaluate(expr.source, universe).filter((entry) => {
+        if (expr.hasText !== undefined && !subtreeHasText(entry, expr.hasText))
+          return false;
+        if (expr.has !== undefined && evaluate(expr.has, descendantsOf(universe, [entry])).length === 0)
+          return false;
+        return true;
+      });
+    case "index": {
+      const source = evaluate(expr.source, universe);
+      const position = expr.index === "first" ? 0 : expr.index === "last" ? source.length - 1 : expr.index;
+      const picked = source[position];
+      return picked === undefined ? [] : [picked];
+    }
+  }
+}
+function resolve2(expr, index) {
+  return evaluate(expr, index.entries);
+}
+var MAX_LISTED = 5;
+function exactlyOne(expr, matches, options = {}) {
+  const screen = options.screen === undefined ? {} : { screen: options.screen };
+  const [first] = matches;
+  if (first === undefined) {
+    return e2eErr({ code: "LOCATOR_NOT_FOUND", message: `${describeExpression(expr)} matched no elements`, ...screen });
+  }
+  if (matches.length === 1)
+    return ok(first);
+  const listed = matches.slice(0, MAX_LISTED).map((entry) => `  ${describeEntry(entry)}`);
+  if (matches.length > MAX_LISTED)
+    listed.push(`  ... and ${matches.length - MAX_LISTED} more`);
+  return e2eErr({
+    code: "LOCATOR_AMBIGUOUS",
+    message: `${describeExpression(expr)} matched ${matches.length} elements:
+${listed.join(`
+`)}`,
+    matches: matches.length,
+    ...screen
+  });
+}
+function describeMatch(match) {
+  return typeof match === "string" ? JSON.stringify(match) : String(match);
+}
+function describeOptions(options) {
+  const present = options.filter(([, value]) => value !== undefined);
+  return present.length === 0 ? "" : `{ ${present.map(([key, value]) => `${key}: ${String(value)}`).join(", ")} }`;
+}
+function describeQuery(query) {
+  switch (query.kind) {
+    case "testId":
+      return `getByTestId(${[describeMatch(query.value), describeOptions([["visible", query.visible]])].filter(Boolean).join(", ")})`;
+    case "role": {
+      const options = describeOptions([
+        ["exact", query.exact],
+        ["checked", query.checked],
+        ["disabled", query.disabled],
+        ["selected", query.selected],
+        ["visible", query.visible]
+      ]);
+      const args = [
+        JSON.stringify(query.role),
+        query.name === undefined ? "" : describeMatch(query.name),
+        options
+      ].filter(Boolean);
+      return `getByRole(${args.join(", ")})`;
+    }
+    case "selector":
+      return `locator(${JSON.stringify(formatSelector(query.selector))})`;
+    case "text":
+    case "label":
+    case "placeholder":
+    case "value": {
+      const method = { text: "getByText", label: "getByLabel", placeholder: "getByPlaceholder", value: "getByValue" }[query.kind];
+      const options = describeOptions([
+        ["exact", query.exact],
+        ["visible", query.visible]
+      ]);
+      return `${method}(${[describeMatch(query.value), options].filter(Boolean).join(", ")})`;
+    }
+  }
+}
+function describeExpression(expr) {
+  switch (expr.kind) {
+    case "query":
+      return expr.scope === undefined ? describeQuery(expr.query) : `${describeExpression(expr.scope)}.${describeQuery(expr.query)}`;
+    case "filter": {
+      const parts = [
+        expr.hasText === undefined ? "" : `hasText: ${describeMatch(expr.hasText)}`,
+        expr.has === undefined ? "" : `has: ${describeExpression(expr.has)}`
+      ].filter(Boolean);
+      return `${describeExpression(expr.source)}.filter({ ${parts.join(", ")} })`;
+    }
+    case "index": {
+      const source = describeExpression(expr.source);
+      if (expr.index === "first")
+        return `${source}.first()`;
+      if (expr.index === "last")
+        return `${source}.last()`;
+      return `${source}.nth(${expr.index})`;
+    }
+  }
+}
+
+// ../../packages/e2e/src/screen/react-locator.ts
+async function locateByTestIdViaReact(facet, testId, view, options = {}) {
+  const treeOptions = {
+    ...view.platform === "android" ? { pixelRatio: view.screen.scale } : {},
+    ...options.screenName === undefined ? {} : { screen: options.screenName },
+    ...options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }
+  };
+  let result;
+  try {
+    result = await facet.tree(treeOptions);
+  } catch {
+    return [];
+  }
+  if (!result.success)
+    return [];
+  const matches = [];
+  for (const component of result.data.components) {
+    const { testID, rect } = component;
+    if (testID === undefined || rect === undefined || !matchesText(testID, testId))
+      continue;
+    matches.push({
+      frame: rect,
+      tapPoint: { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 },
+      source: "react",
+      testId: testID,
+      name: component.name
+    });
+  }
+  return matches;
+}
+function reactTapPoint(match, position) {
+  if (position === undefined)
+    return match.tapPoint;
+  return { x: match.frame.x + position.x, y: match.frame.y + position.y };
+}
+
+// ../../packages/e2e/src/screen/locator.ts
+var WAIT_STATES = ["attached", "detached", "visible", "hidden"];
+var DEFAULT_MAX_SWIPES = 10;
+var VERIFY_MS = 1000;
+var CONFIRM_FLOOR_MS = 500;
+var SCROLL_SETTLE = { quietMs: 150, timeoutMs: 1000 };
+function assertOptions(verb, options, allowed) {
+  const unknown = Object.keys(options).filter((key) => !allowed.includes(key));
+  if (unknown.length > 0) {
+    throw new E2eError("INVALID_ARGUMENT", `${verb} does not take ${unknown.map((key) => `"${key}"`).join(", ")}; it takes ${allowed.join(", ")}`);
+  }
+}
+var REACT_ONLY = "exists only in the React tree, not in the accessibility tree, so only tap() and boundingBox() work on it; " + "expose it to accessibility (accessible, accessibilityLabel) to use anything else";
+function plainTestId(expr) {
+  if (expr.kind !== "query" || expr.scope !== undefined || expr.query.kind !== "testId")
+    return;
+  return expr.query.value;
+}
+var LOCATOR_BRAND = Symbol.for("@delacour/warden-e2e/locator");
+function isLocator(value) {
+  return typeof value === "object" && value !== null && LOCATOR_BRAND in value;
+}
+
+class Locator {
+  expr;
+  rt;
+  [LOCATOR_BRAND] = true;
+  constructor(expr, rt) {
+    this.expr = expr;
+    this.rt = rt;
+  }
+  toString() {
+    return describeExpression(this.expr);
+  }
+  scoped(query) {
+    return new Locator({ kind: "query", query, scope: this.expr }, this.rt);
+  }
+  getByTestId(id, options) {
+    return this.scoped(testIdQuery(id, options));
+  }
+  getByText(text, options) {
+    return this.scoped(textQuery("text", text, options));
+  }
+  getByLabel(text, options) {
+    return this.scoped(textQuery("label", text, options));
+  }
+  getByPlaceholder(text, options) {
+    return this.scoped(textQuery("placeholder", text, options));
+  }
+  getByValue(value, options) {
+    return this.scoped(textQuery("value", value, options));
+  }
+  getByRole(role, nameOrOptions, options) {
+    return this.scoped(roleQuery(role, nameOrOptions, options));
+  }
+  locator(selector) {
+    return new Locator(withScope(selectorExpression(selector), this.expr), this.rt);
+  }
+  filter(options) {
+    const unknown = Object.keys(options).filter((key) => key !== "hasText" && key !== "has");
+    if (unknown.length > 0) {
+      throw new E2eError("INVALID_LOCATOR", `filter takes "hasText" and "has", not ${unknown.map((k) => `"${k}"`).join(", ")}`);
+    }
+    const { hasText, has } = options;
+    if (hasText === undefined && has === undefined) {
+      throw new E2eError("INVALID_LOCATOR", 'filter needs "hasText" or "has"');
+    }
+    if (has !== undefined && !(has instanceof Locator)) {
+      throw new E2eError("INVALID_LOCATOR", 'filter "has" must be a locator made by screen');
+    }
+    return new Locator({
+      kind: "filter",
+      source: this.expr,
+      ...hasText === undefined ? {} : { hasText },
+      ...has === undefined ? {} : { has: has.expr }
+    }, this.rt);
+  }
+  first() {
+    return new Locator({ kind: "index", source: this.expr, index: "first" }, this.rt);
+  }
+  last() {
+    return new Locator({ kind: "index", source: this.expr, index: "last" }, this.rt);
+  }
+  nth(index) {
+    if (!Number.isInteger(index) || index < 0) {
+      throw new E2eError("INVALID_LOCATOR", `nth takes a non-negative integer, got ${String(index)}`);
+    }
+    return new Locator({ kind: "index", source: this.expr, index }, this.rt);
+  }
+  get runtime() {
+    return this.rt;
+  }
+  async look(options = {}) {
+    const observed = await this.rt.observe(options);
+    return { entries: resolve2(this.expr, observed.index), observed };
+  }
+  matches() {
+    return this.look();
+  }
+  async single() {
+    const { entries, observed } = await this.matches();
+    if (entries.length === 0 && (await this.reactCandidates(observed)).length > 0) {
+      throw new E2eError("NOT_ACTIONABLE", `${this} ${REACT_ONLY}`, this.rt.excerpt(observed.snapshot));
+    }
+    return { entry: this.exactlyOne(entries, observed), observed };
+  }
+  async reactCandidates(observed) {
+    const testId = plainTestId(this.expr);
+    return testId === undefined ? [] : this.rt.reactMatches(testId, observed);
+  }
+  exactlyOne(entries, observed) {
+    return pickOne(this.rt, this.expr, entries, observed);
+  }
+  traced(name, run) {
+    return this.rt.span(`read.${name}`, run, { detail: () => ({ locator: this.toString() }) });
+  }
+  count() {
+    return this.traced("count", async () => (await this.matches()).entries.length);
+  }
+  async all() {
+    const count = await this.count();
+    return Array.from({ length: count }, (_, index) => this.nth(index));
+  }
+  text() {
+    return this.traced("text", async () => textOf2((await this.single()).entry));
+  }
+  allTexts() {
+    return this.traced("allTexts", async () => (await this.matches()).entries.map(textOf2));
+  }
+  value() {
+    return this.traced("value", async () => fieldValue((await this.single()).entry));
+  }
+  isVisible() {
+    return this.traced("isVisible", async () => this.visibleIn((await this.matches()).observed));
+  }
+  read() {
+    return this.traced("read", async () => {
+      const { entries, observed } = await this.matches();
+      if (entries.length === 0)
+        return { visible: false };
+      const entry = this.exactlyOne(entries, observed);
+      return {
+        visible: entry.visible,
+        text: textOf2(entry),
+        value: fieldValue(entry),
+        ...entry.states.checked === undefined ? {} : { checked: entry.states.checked }
+      };
+    });
+  }
+  visibleIn(observed) {
+    const entries = resolve2(this.expr, observed.index);
+    if (entries.length === 0)
+      return false;
+    return this.exactlyOne(entries, observed).visible;
+  }
+  async isHidden() {
+    return !await this.isVisible();
+  }
+  isEnabled() {
+    return this.traced("isEnabled", async () => !(await this.single()).entry.states.disabled);
+  }
+  isChecked() {
+    return this.traced("isChecked", async () => (await this.single()).entry.states.checked === true);
+  }
+  boundingBox() {
+    return this.traced("boundingBox", async () => {
+      const { entries, observed } = await this.look({ reuse: false });
+      if (entries.length === 0) {
+        const [only, ...others] = await this.reactCandidates(observed);
+        if (only !== undefined && others.length === 0)
+          return { ...only.frame };
+      }
+      return { ...this.exactlyOne(entries, observed).element.frame };
+    });
+  }
+  waitFor(options = {}) {
+    return this.traced("waitFor", () => this.waitForState(options));
+  }
+  async waitForState(options) {
+    assertOptions("waitFor", options, ["state", "timeout"]);
+    const state = options.state ?? "visible";
+    if (!WAIT_STATES.includes(state)) {
+      throw new E2eError("INVALID_ARGUMENT", `waitFor state must be one of ${WAIT_STATES.join(", ")}, got "${String(state)}"`);
+    }
+    const timeoutMs = options.timeout ?? this.rt.actionTimeout();
+    const result = await this.rt.poll(async (attempt) => {
+      const observation = await this.rt.tryObserve({ reuse: attempt === 1 });
+      if (!observation.ok) {
+        if (!observation.error.retryable)
+          throw new E2eError("DRIVER", `snapshot failed: ${observation.error.message}`);
+        return { done: false, state: undefined };
+      }
+      const { observed } = observation;
+      const entries = resolve2(this.expr, observed.index);
+      const entry = entries.length === 0 ? undefined : this.exactlyOne(entries, observed);
+      return reached(state, entry) ? { done: true, value: true } : { done: false, state: observed.snapshot };
+    }, timeoutMs);
+    if (result.status === "done")
+      return;
+    const message = `${this} did not become ${state} within ${timeoutMs} ms`;
+    throw new E2eError("TIMEOUT", message, result.last === undefined ? undefined : this.rt.excerpt(result.last));
+  }
+  act(verb, run, suffix = "") {
+    return this.rt.step(`${verb} ${this}${suffix}`, run);
+  }
+  async actionable(spec, timeoutMs, allowReact = false) {
+    let extraLooks = 0;
+    const result = await this.rt.poll(async () => {
+      for (;; ) {
+        const step = await this.actionableLook(spec, allowReact, extraLooks >= MAX_STABILITY_LOOKS);
+        if (step !== "moving")
+          return step;
+        extraLooks += 1;
+      }
+    }, timeoutMs);
+    if (result.status === "done")
+      return result.value;
+    const seen = result.last;
+    if (seen?.kind === "blocked") {
+      throw new E2eError("NOT_ACTIONABLE", `${this} ${seen.reason} (waited ${timeoutMs} ms)`, this.rt.excerpt(seen.snapshot));
+    }
+    if (seen?.kind === "react") {
+      throw new E2eError("NOT_ACTIONABLE", `${this} ${REACT_ONLY} (waited ${timeoutMs} ms)`, this.rt.excerpt(seen.snapshot), seen.matches);
+    }
+    if (seen?.kind === "driver")
+      throw new E2eError("DRIVER", `snapshot kept failing: ${seen.message}`);
+    throw new E2eError("LOCATOR_NOT_FOUND", `${this} matched no elements within ${timeoutMs} ms`, seen === undefined ? undefined : this.rt.excerpt(seen.snapshot));
+  }
+  async actionableLook(spec, allowReact, anyFrame) {
+    const observation = await this.rt.tryObserve({ reuse: false, withPrevious: true });
+    if (!observation.ok) {
+      if (!observation.error.retryable) {
+        throw new E2eError("DRIVER", `snapshot failed: ${observation.error.code}: ${observation.error.message}`);
+      }
+      return { done: false, state: { kind: "driver", message: observation.error.message } };
+    }
+    const { observed } = observation;
+    const entries = resolve2(this.expr, observed.index);
+    if (entries.length === 0)
+      return this.reactStep(spec, observed, allowReact);
+    const entry = this.exactlyOne(entries, observed);
+    const reason = blockedReason(entry, spec, observed);
+    if (reason !== undefined)
+      return { done: false, state: { kind: "blocked", reason, snapshot: observed.snapshot } };
+    if (!anyFrame && !this.heldStill(entry, observation.earlier))
+      return "moving";
+    return { done: true, value: { entry, observed } };
+  }
+  heldStill(entry, earlier) {
+    if (earlier === undefined)
+      return true;
+    const { previous, sinceInputMs } = earlier;
+    if (previous === undefined)
+      return sinceInputMs === undefined || sinceInputMs >= STABLE_INPUT_GAP_MS;
+    const [before, ...others] = resolve2(this.expr, previous.index);
+    return before !== undefined && others.length === 0 && sameFrame(before.element.frame, entry.element.frame);
+  }
+  async aimFromKept(spec, position) {
+    const driver = await this.rt.host.driver();
+    if (driver.capabilities.cheapHitTest !== true || !canObserve(driver))
+      return;
+    if (this.rt.host.answerSystemAlert !== undefined)
+      return;
+    const kept = driver.peek?.();
+    if (kept === undefined || kept.ageMs >= OBSERVATION_MAX_AGE_MS[driver.platform] || showsAlert(driver, kept.snapshot))
+      return;
+    const observation = await this.rt.tryObserve({ reuse: true, alerts: false });
+    if (!observation.ok || observation.observed.snapshot !== kept.snapshot)
+      return;
+    const { observed } = observation;
+    const [entry, ...others] = resolve2(this.expr, observed.index);
+    if (entry === undefined || others.length > 0 || blockedReason(entry, spec, observed) !== undefined)
+      return;
+    const hit = await observed.driver.elementAtPoint(tapPointOf(entry, position));
+    if (!hit.success || hit.data === null || !sameElement(hit.data, entry.element))
+      return;
+    return { entry, observed };
+  }
+  async tap(options = {}) {
+    assertOptions("tap", options, ["position", "timeout", "until", "retries", "windowMs", "pollMs"]);
+    const retry = retryPlan(options);
+    const suffix = retry === undefined ? "" : ` until ${describeUntil(retry.until)}`;
+    return this.act("tap", async () => {
+      let before = await this.tapOnce(options);
+      if (retry === undefined)
+        return;
+      for (let resent = 0;resent < retry.retries; resent += 1) {
+        const outcome = await this.arrivedWithin(retry, snapshotHash(before));
+        if (outcome !== "press-again")
+          return;
+        before = await this.tapOnce(options);
+      }
+    }, suffix);
+  }
+  async tapOnce(options) {
+    const withPosition = options.position !== undefined;
+    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));
+    return found.observed.snapshot;
+  }
+  async arrivedWithin(plan, pressedOn) {
+    const { until } = plan;
+    const watch = { pressedOn, started: this.rt.clock.now(), changed: false, unchanged: 0 };
+    const result = await this.rt.poll(async (attempt) => {
+      if (typeof until !== "function")
+        return this.checkLocatorUntil(until, watch, attempt);
+      if (attempt > 1)
+        await this.rt.forgetObservation();
+      return await until() ? { done: true, value: "arrived" } : { done: false, state: undefined };
+    }, plan.windowMs, { intervalMs: plan.pollMs });
+    if (result.status === "done")
+      return result.value;
+    return watch.changed ? "landed" : "press-again";
+  }
+  async checkLocatorUntil(until, watch, attempt) {
+    const observation = await until.runtime.tryObserve({ reuse: attempt === 1 });
+    if (!observation.ok) {
+      if (!observation.error.retryable) {
+        throw new E2eError("DRIVER", `snapshot failed: ${observation.error.code}: ${observation.error.message}`);
+      }
+      watch.unchanged = 0;
+      return { done: false, state: undefined };
+    }
+    if (until.visibleIn(observation.observed))
+      return { done: true, value: "arrived" };
+    if (snapshotHash(observation.observed.snapshot) === watch.pressedOn)
+      watch.unchanged += 1;
+    else {
+      watch.changed = true;
+      watch.unchanged = 0;
+    }
+    const dropped = !watch.changed && watch.unchanged >= UNCHANGED_CHECKS && this.rt.clock.now() - watch.started >= UNCHANGED_AFTER_MS;
+    return dropped ? { done: true, value: "press-again" } : { done: false, state: undefined };
+  }
+  async longPress(options = {}) {
+    assertOptions("longPress", options, ["durationMs", "timeout"]);
+    return this.act("longPress", async () => {
+      const { entry, observed } = await this.actionable({ enabled: true, tapPointOnScreen: true }, options.timeout ?? this.rt.actionTimeout());
+      const opts = options.durationMs === undefined ? undefined : { durationMs: options.durationMs };
+      this.rt.drive("longPress", await observed.driver.longPress(tapPointOf(entry), opts));
+    });
+  }
+  async fill(text, options = {}) {
+    assertOptions("fill", options, ["timeout"]);
+    return this.act("fill", async () => {
+      const budget = this.rt.budget(options.timeout);
+      let target = await this.actionable({ enabled: true, tapPointOnScreen: false }, budget.remaining());
+      let firstHeld;
+      for (let attempt = 1;; attempt += 1) {
+        const point = focusPoint(target.entry.element.frame);
+        this.rt.drive("fill", await focusClearType(target.observed.driver, this.pause, point, target.entry, text, clearMethodFor(attempt)));
+        if (target.entry.secure)
+          return;
+        const outcome = await this.confirm(target, text, budget);
+        if (outcome.ok)
+          return;
+        if (attempt === 2) {
+          const earlier = firstHeld === undefined ? "" : ` (first attempt held ${JSON.stringify(firstHeld)})`;
+          throw new E2eError("ACTION_FAILED", `${this}: fill did not take: expected ${JSON.stringify(text)} but the field holds ${JSON.stringify(outcome.held)}${earlier}`, outcome.screen);
+        }
+        firstHeld = outcome.held;
+        target = await this.actionable({ enabled: true, tapPointOnScreen: false }, budget.remaining());
+      }
+    });
+  }
+  async clear(options = {}) {
+    assertOptions("clear", options, ["timeout"]);
+    return this.act("clear", async () => {
+      const budget = this.rt.budget(options.timeout);
+      let target = await this.actionable({ enabled: true, tapPointOnScreen: false }, budget.remaining());
+      for (let attempt = 1;; attempt += 1) {
+        await this.focusAndClear(target, clearMethodFor(attempt));
+        if (target.entry.secure)
+          return;
+        const outcome = await this.confirm(target, "", budget);
+        if (outcome.ok)
+          return;
+        if (attempt === 2) {
+          throw new E2eError("ACTION_FAILED", `${this}: clear did not empty the field: it holds ${JSON.stringify(outcome.held)}`, outcome.screen);
+        }
+        target = await this.actionable({ enabled: true, tapPointOnScreen: false }, budget.remaining());
+      }
+    });
+  }
+  async type(text, options = {}) {
+    assertOptions("type", options, ["timeout"]);
+    return this.act("type", async () => {
+      const target = await this.actionable({ enabled: true, tapPointOnScreen: false }, options.timeout ?? this.rt.actionTimeout());
+      await this.focus(target);
+      this.rt.drive("type", await typeText(target.observed.driver, this.pause, text));
+    });
+  }
+  async press(key, options = {}) {
+    assertOptions("press", options, ["modifiers", "timeout"]);
+    return this.act("press", async () => {
+      const target = await this.actionable({ enabled: true, tapPointOnScreen: false }, options.timeout ?? this.rt.actionTimeout());
+      await this.focus(target);
+      this.rt.drive("press", await target.observed.driver.key(key, options.modifiers));
+    });
+  }
+  async swipe(options) {
+    assertOptions("swipe", options, ["direction", "momentum", "timeout"]);
+    if (options.direction === undefined) {
+      throw new E2eError("INVALID_ARGUMENT", "a locator swipe needs a direction; paths are only for screen.swipe");
+    }
+    return this.act("swipe", async () => {
+      const { entry, observed } = await this.actionable({ enabled: false, tapPointOnScreen: false }, options.timeout ?? this.rt.actionTimeout());
+      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));
+    });
+  }
+  async pinch(scale2, options = {}) {
+    assertOptions("pinch", options, ["durationMs", "radius", "timeout"]);
+    assertScale(scale2);
+    return this.act("pinch", async () => {
+      const { entry, observed } = await this.actionable({ enabled: false, tapPointOnScreen: false }, options.timeout ?? this.rt.actionTimeout());
+      const screen = observed.snapshot.screen;
+      const rect = visibleRect(entry.element.frame, screen);
+      requireGesture(observed.driver, "pinch", "locator.pinch");
+      this.rt.drive("pinch", await observed.driver.pinch(centreOf(rect), scale2, {
+        durationMs: options.durationMs ?? PINCH_MS,
+        radius: options.radius ?? pinchRadius(rect, scale2, screen)
+      }));
+    }, ` \xD7${scale2}`);
+  }
+  async rotate(degrees, options = {}) {
+    assertOptions("rotate", options, ["durationMs", "radius", "timeout"]);
+    assertDegrees(degrees);
+    return this.act("rotate", async () => {
+      const { entry, observed } = await this.actionable({ enabled: false, tapPointOnScreen: false }, options.timeout ?? this.rt.actionTimeout());
+      const screen = observed.snapshot.screen;
+      const rect = visibleRect(entry.element.frame, screen);
+      requireGesture(observed.driver, "pinch", "locator.rotate");
+      this.rt.drive("rotate", await observed.driver.rotate(centreOf(rect), degrees, {
+        durationMs: options.durationMs ?? ROTATE_MS,
+        radius: options.radius ?? rotateRadius(rect, screen)
+      }));
+    }, ` ${degrees}\xB0`);
+  }
+  scrollTo(options = {}) {
+    return scrollUntilVisible(this.rt, this, options);
+  }
+  async reactStep(spec, observed, allowReact) {
+    const found = await this.reactCandidates(observed);
+    const [match, ...others] = found;
+    if (match === undefined)
+      return { done: false, state: { kind: "none", snapshot: observed.snapshot } };
+    if (!allowReact)
+      return { done: false, state: { kind: "react", snapshot: observed.snapshot, matches: found.length } };
+    if (others.length > 0) {
+      throw new E2eError("LOCATOR_AMBIGUOUS", `${this} matched ${found.length} components in the React tree`, this.rt.excerpt(observed.snapshot), found.length);
+    }
+    if (spec.tapPointOnScreen && !isOnScreen(match.tapPoint, observed.snapshot.screen)) {
+      const reason = "(React tree) has its tap point outside the screen";
+      return { done: false, state: { kind: "blocked", reason, snapshot: observed.snapshot } };
+    }
+    return { done: true, value: { react: match, observed } };
+  }
+  async focus({ entry, observed }) {
+    if (entry.states.focused)
+      return;
+    this.rt.drive("focus", await tapToFocus(observed.driver, this.pause, focusPoint(entry.element.frame), entry));
+  }
+  async focusAndClear({ entry, observed }, method) {
+    this.rt.drive("clear", await focusAndClear(observed.driver, this.pause, focusPoint(entry.element.frame), entry, method));
+  }
+  pause = (ms) => this.rt.clock.sleep(ms, this.rt.host.signal);
+  async confirm({ entry, observed }, text, budget) {
+    const span = Math.max(budget.remaining(), CONFIRM_FLOOR_MS);
+    let lastSeen;
+    const readValue2 = (found) => text === "" ? fieldValue(found) : rawValue(found);
+    const outcome = await confirmFieldValue({
+      text,
+      now: this.rt.clock.now,
+      sleep: this.pause,
+      budgetMs: Math.min(VERIFY_MS, span),
+      reads: confirmReadsFor(entry, text),
+      maxMs: span,
+      read: async () => {
+        const hit = await hitTestField(observed.driver, entry);
+        if (hit.ok && hit.entry !== undefined)
+          return { ok: true, reading: { kind: "value", value: readValue2(hit.entry) } };
+        const observation = await this.rt.tryObserve({ reuse: false, alerts: false });
+        if (!observation.ok)
+          return { ok: true, reading: { kind: "unreadable", note: "(unreadable)" } };
+        lastSeen = observation.observed.snapshot;
+        const found = resolve2(this.expr, observation.observed.index);
+        const [only] = found;
+        if (found.length !== 1 || only === undefined) {
+          return { ok: true, reading: { kind: "unreadable", note: `(${found.length} matches)` } };
+        }
+        return { ok: true, reading: { kind: "value", value: readValue2(only) } };
+      }
+    });
+    if (outcome.status === "confirmed")
+      return { ok: true };
+    const held = outcome.status === "mismatch" ? outcome.held : "(unreadable)";
+    return { ok: false, held, screen: lastSeen === undefined ? undefined : this.rt.excerpt(lastSeen) };
+  }
+}
+function pickOne(rt, expr, entries, observed) {
+  const [only] = entries;
+  if (only !== undefined && entries.length === 1)
+    return only;
+  const result = exactlyOne(expr, entries, { screen: rt.excerpt(observed.snapshot) });
+  if (!result.success)
+    throw result.error;
+  return result.data;
+}
+function textOf2(entry) {
+  return normalizeText(entry.name ?? "") || entry.subtreeText;
+}
+var STABLE_INPUT_GAP_MS = 300;
+var MAX_STABILITY_LOOKS = 2;
+function sameElement(hit, seen) {
+  return hit.role === seen.role && hit.identifier === seen.identifier && hit.label === seen.label && hit.enabled === seen.enabled && sameFrame(hit.frame, seen.frame);
+}
+function showsAlert(driver, snapshot) {
+  return snapshot.modal !== undefined || canDetectAlerts(driver) && driver.alertIn(snapshot) !== null;
+}
+function sameFrame(a, b) {
+  return Math.round(a.x) === Math.round(b.x) && Math.round(a.y) === Math.round(b.y) && Math.round(a.width) === Math.round(b.width) && Math.round(a.height) === Math.round(b.height);
+}
+var TAP_RETRIES = 2;
+var TAP_WINDOW_MS = 4000;
+var TAP_CHECK_MS = 250;
+var UNCHANGED_CHECKS = 2;
+var UNCHANGED_AFTER_MS = 750;
+function wholeNumber(name, value, atLeast) {
+  if (!Number.isInteger(value) || value < atLeast) {
+    throw new E2eError("INVALID_ARGUMENT", `tap ${name} must be an integer of at least ${atLeast}, got ${String(value)}`);
+  }
+}
+function retryPlan(options) {
+  const { until, retries, windowMs, pollMs } = options;
+  if (until === undefined) {
+    const orphan = ["retries", "windowMs", "pollMs"].filter((key) => options[key] !== undefined);
+    if (orphan.length > 0) {
+      throw new E2eError("INVALID_ARGUMENT", `tap ${orphan.map((key) => `"${key}"`).join(", ")} only apply with "until"`);
+    }
+    return;
+  }
+  if (typeof until !== "function" && !isLocator(until)) {
+    throw new E2eError("INVALID_ARGUMENT", 'tap "until" must be a locator made by screen, or a function returning a promise of a boolean');
+  }
+  const plan = {
+    until,
+    retries: retries ?? TAP_RETRIES,
+    windowMs: windowMs ?? TAP_WINDOW_MS,
+    pollMs: pollMs ?? TAP_CHECK_MS
+  };
+  wholeNumber("retries", plan.retries, 0);
+  wholeNumber("windowMs", plan.windowMs, 1);
+  wholeNumber("pollMs", plan.pollMs, 1);
+  return plan;
+}
+function describeUntil(until) {
+  return typeof until === "function" ? "check" : String(until);
+}
+function clearMethodFor(attempt) {
+  return attempt === 1 ? "auto" : "counted";
+}
+function rawValue(entry) {
+  return entry.value ?? (entry.role === "textbox" || entry.role === "searchbox" ? entry.element.text ?? "" : "");
+}
+function reached(state, entry) {
+  switch (state) {
+    case "attached":
+      return entry !== undefined;
+    case "detached":
+      return entry === undefined;
+    case "visible":
+      return entry?.visible === true;
+    case "hidden":
+      return entry === undefined || !entry.visible;
+  }
+}
+function blockedReason(entry, spec, observed) {
+  if (!entry.visible)
+    return "is not visible";
+  if (spec.enabled && entry.states.disabled)
+    return "is disabled";
+  if (spec.tapPointOnScreen && !isOnScreen(tapPointOf(entry), observed.snapshot.screen)) {
+    return "has its tap point outside the screen; use scrollTo() to bring it into view";
+  }
+  return;
+}
+function isOnScreenEntry(entry, observed) {
+  return entry?.visible === true && isOnScreen(tapPointOf(entry), observed.snapshot.screen);
+}
+function scrollGaveUp(target, absent, effort, screen) {
+  if (absent)
+    return new E2eError("LOCATOR_NOT_FOUND", `${target} was not found after ${effort}`, screen);
+  return new E2eError("NOT_ACTIONABLE", `${target} is still not on screen after ${effort}`, screen);
+}
+async function scrollUntilVisible(rt, target, options = {}) {
+  assertOptions("scrollUntilVisible", options, ["direction", "momentum", "maxSwipes", "timeout"]);
+  const direction = options.direction ?? "down";
+  const maxSwipes = options.maxSwipes ?? DEFAULT_MAX_SWIPES;
+  if (!Number.isInteger(maxSwipes) || maxSwipes < 0) {
+    throw new E2eError("INVALID_ARGUMENT", `maxSwipes must be a non-negative integer, got ${String(maxSwipes)}`);
+  }
+  return rt.step(`scrollUntilVisible ${target}`, async () => {
+    const budget = rt.budget(options.timeout);
+    for (let swipes = 0;; swipes += 1) {
+      const observed = await rt.observe();
+      const entries = resolve2(target.expr, observed.index);
+      if (entries.length > 1)
+        pickOne(rt, target.expr, entries, observed);
+      const [entry] = entries;
+      if (isOnScreenEntry(entry, observed))
+        return;
+      if (swipes >= maxSwipes || budget.remaining() <= 0) {
+        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));
+      await observed.driver.settle(SCROLL_SETTLE);
+    }
+  });
+}
+
+// ../../packages/e2e/src/runner/artifacts.ts
+import { createHash } from "crypto";
+import { basename, extname, join as join3, 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);
+}
+function attemptDir(out, flowId, title, hash) {
+  return join3(out, flowId, `${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`);
+}
+var SPEC_EXT = /\.e2e$/;
+function flowIdOf(file, flowsDir) {
+  const strip = (name) => basename(name, extname(name)).replace(SPEC_EXT, "");
+  if (flowsDir !== undefined) {
+    const rel = relative(flowsDir, file);
+    if (rel !== "" && !rel.startsWith("..") && !rel.includes(`..${sep}`)) {
+      const parts = rel.split(sep);
+      const last = parts.pop() ?? rel;
+      return [...parts.map((p) => slug(p, "dir")), slug(strip(last), "flow")].join("/");
+    }
+  }
+  return slug(strip(file), "flow");
+}
+
+export { E2eError, 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, resolve2 as resolve, locateByTestIdViaReact, isLocator, Locator, pickOne, textOf2 as textOf, scrollUntilVisible, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, hash6, attemptDir, screenshotPath, flowIdOf, callerFile, BUN_TIMEOUT_MARGIN_MS, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION };