@delacour/warden-e2e 0.13.0 → 0.14.0

package/{chunk-tnr47n9c.mjs → chunk-zk3wxa70.mjs}

@@ -236,6 +236,10 @@ function settleDetailOf(outcome) {
 }
 var DEFAULT_SETTLE_QUIET_MS = 250;
 var DEFAULT_SETTLE_TIMEOUT_MS = 3000;
+var HASH_FALLBACK_MIN_QUIET_MS = 500;
+function hashFallbackQuietMs(quietMs) {
+  return Math.max(quietMs, HASH_FALLBACK_MIN_QUIET_MS);
+}
 var DEFAULT_POLL_MS = 50;
 async function settleByHash(poll, deps) {
   const { quietMs, timeoutMs, now, sleep } = deps;
@@ -479,6 +483,34 @@ function assertDegrees(degrees) {
   }
 }
 
+// ../../packages/e2e/src/screen/degraded-read.ts
+function degradedRead(snapshot) {
+  if (snapshot.fellBackFrom !== undefined) {
+    return { kind: "fallback", from: snapshot.fellBackFrom, backend: snapshot.backend };
+  }
+  const [root, ...others] = snapshot.elements;
+  if (root !== undefined && others.length === 0 && root.children.length === 0) {
+    const { width, height } = root.frame;
+    if (width * height === 0)
+      return { kind: "emptyRoot", backend: snapshot.backend };
+  }
+  return;
+}
+function describeDegraded(read) {
+  if (read.kind === "emptyRoot")
+    return `the ${read.backend} read returned an empty root (backend: ${read.backend})`;
+  return `the read fell back from ${read.from} to ${read.backend} (fellBackFrom: ${read.from}, backend: ${read.backend}), which can drop React Native testIDs`;
+}
+var REACT_NOTES = {
+  unanswered: "the React tree did not answer",
+  "no-devtools": "there is no React tree to ask (no devtools: not a dev client with Metro)",
+  "not-testid": "only a plain getByTestId can be asked of the React tree"
+};
+function degradedFailure(locator, read, waitedMs, react, screen) {
+  const message = `${locator} could not be confirmed within ${waitedMs} ms: bridge degraded, ${describeDegraded(read)}, ` + `and ${REACT_NOTES[react]}. A missing node on such a read is not proof of absence.`;
+  return new E2eError2("READ_DEGRADED", message, screen);
+}
+
 // ../../packages/e2e/src/screen/roles.ts
 var QUERY_ROLES = [
   "button",
@@ -1534,7 +1566,7 @@ function describeExpression(expr) {
 }
 
 // ../../packages/e2e/src/screen/react-locator.ts
-async function locateByTestIdViaReact(facet, testId, view, options = {}) {
+async function lookUpTestIdViaReact(facet, testId, view, options = {}) {
   const treeOptions = {
     ...view.platform === "android" ? { pixelRatio: view.screen.scale } : {},
     ...options.screenName === undefined ? {} : { screen: options.screenName },
@@ -1544,10 +1576,10 @@ async function locateByTestIdViaReact(facet, testId, view, options = {}) {
   try {
     result = await facet.tree(treeOptions);
   } catch {
-    return [];
+    return { answered: false };
   }
   if (!result.success)
-    return [];
+    return { answered: false };
   const matches = [];
   for (const component of result.data.components) {
     const { testID, rect } = component;
@@ -1558,10 +1590,11 @@ async function locateByTestIdViaReact(facet, testId, view, options = {}) {
       tapPoint: { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 },
       source: "react",
       testId: testID,
-      name: component.name
+      name: component.name,
+      ...component.text === undefined ? {} : { text: component.text }
     });
   }
-  return matches;
+  return { answered: true, matches };
 }
 function reactTapPoint(match, position) {
   if (position === undefined)
@@ -1569,6 +1602,41 @@ function reactTapPoint(match, position) {
   return { x: match.frame.x + position.x, y: match.frame.y + position.y };
 }
 
+// ../../packages/e2e/src/screen/react-merge.ts
+var EDGE_SLACK = 1.5;
+function sameRect(a, b) {
+  if (a.width <= 0 || a.height <= 0 || b.width <= 0 || b.height <= 0)
+    return false;
+  return Math.abs(a.x - b.x) <= EDGE_SLACK && Math.abs(a.y - b.y) <= EDGE_SLACK && Math.abs(a.x + a.width - (b.x + b.width)) <= EDGE_SLACK && Math.abs(a.y + a.height - (b.y + b.height)) <= EDGE_SLACK;
+}
+function ownText(entry) {
+  return normalizeText(entry.name ?? entry.value ?? "");
+}
+function nodeOfReactMatch(match, index) {
+  const candidates = index.entries.filter((entry) => {
+    const id = entry.element.identifier;
+    return (id === undefined || id === match.testId) && sameRect(entry.element.frame, match.frame);
+  });
+  const text = match.text === undefined ? "" : normalizeText(match.text);
+  const worded = text === "" ? [] : candidates.filter((entry) => ownText(entry) === text);
+  const pool = worded.length > 0 ? worded : candidates;
+  let best;
+  for (const entry of pool)
+    if (best === undefined || entry.depth > best.depth)
+      best = entry;
+  return best;
+}
+function mergeReactMatches(matches, index) {
+  const entries = [];
+  for (const match of matches) {
+    const entry = nodeOfReactMatch(match, index);
+    if (entry === undefined || entries.includes(entry))
+      return;
+    entries.push(entry);
+  }
+  return entries;
+}
+
 // ../../packages/e2e/src/screen/locator.ts
 var WAIT_STATES = ["attached", "detached", "visible", "hidden"];
 var DEFAULT_MAX_SWIPES = 10;
@@ -1581,6 +1649,9 @@ function assertOptions(verb, options, allowed) {
     throw new E2eError2("INVALID_ARGUMENT", `${verb} does not take ${unknown.map((key) => `"${key}"`).join(", ")}; it takes ${allowed.join(", ")}`);
   }
 }
+function reactVisible(match, observed) {
+  return match.frame.width > 0 && match.frame.height > 0 && isOnScreen(match.tapPoint, observed.snapshot.screen);
+}
 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")
@@ -1665,8 +1736,78 @@ class Locator {
     const observed = await this.rt.observe(options);
     return { entries: resolve(this.expr, observed.index), observed };
   }
-  matches() {
-    return this.look();
+  async resolveIn(observed) {
+    const entries = resolve(this.expr, observed.index);
+    if (entries.length > 0)
+      return { kind: "nodes", entries };
+    const read = degradedRead(observed.snapshot);
+    if (read === undefined)
+      return { kind: "nodes", entries };
+    const testId = plainTestId(this.expr);
+    const lookup = testId === undefined ? undefined : await this.rt.reactLookup(testId, observed);
+    if (lookup === undefined || !lookup.answered)
+      return { kind: "unknown", read };
+    if (lookup.matches.length === 0)
+      return { kind: "nodes", entries };
+    const merged = mergeReactMatches(lookup.matches, observed.index);
+    return merged === undefined ? { kind: "react", matches: lookup.matches } : { kind: "nodes", entries: merged };
+  }
+  reactNote() {
+    if (plainTestId(this.expr) === undefined)
+      return "not-testid";
+    return this.rt.hasReactTree() ? "unanswered" : "no-devtools";
+  }
+  degradedFailure(read, waitedMs, snapshot) {
+    const screen = snapshot === undefined ? undefined : this.rt.excerpt(snapshot);
+    return degradedFailure(this.toString(), read, waitedMs, this.reactNote(), screen);
+  }
+  async conclusive(options = {}) {
+    const first = await this.look(options);
+    const settled = await this.settled(first.observed);
+    if (settled !== undefined)
+      return settled;
+    const timeoutMs = this.rt.actionTimeout();
+    let last;
+    const result = await this.rt.poll(async () => {
+      const observation = await this.rt.tryObserve({ reuse: false });
+      if (!observation.ok) {
+        if (!observation.error.retryable)
+          throw new E2eError2("DRIVER", `snapshot failed: ${observation.error.message}`);
+        return { done: false, state: undefined };
+      }
+      const answer = await this.settled(observation.observed);
+      if (answer !== undefined)
+        return { done: true, value: answer };
+      const read = degradedRead(observation.observed.snapshot);
+      if (read !== undefined)
+        last = { read, snapshot: observation.observed.snapshot };
+      return { done: false, state: undefined };
+    }, timeoutMs);
+    if (result.status === "done")
+      return result.value;
+    const fallback = degradedRead(first.observed.snapshot);
+    const read = last?.read ?? fallback;
+    if (read === undefined)
+      throw new E2eError2("TIMEOUT", `${this} could not be read within ${timeoutMs} ms`);
+    throw this.degradedFailure(read, timeoutMs, last?.snapshot ?? first.observed.snapshot);
+  }
+  async settled(observed) {
+    const resolved = await this.resolveIn(observed);
+    if (resolved.kind === "unknown")
+      return;
+    if (resolved.kind === "react")
+      return { entries: [], react: resolved.matches, observed };
+    return { entries: resolved.entries, react: undefined, observed };
+  }
+  async matches() {
+    const { entries, observed } = await this.conclusive();
+    return { entries, observed };
+  }
+  reactOnly(matches, observed) {
+    const [only, ...others] = matches;
+    if (only !== undefined && others.length === 0)
+      return only;
+    throw new E2eError2("LOCATOR_AMBIGUOUS", `${this} matched ${matches.length} components in the React tree`, this.rt.excerpt(observed.snapshot), matches.length);
   }
   async single() {
     const { entries, observed } = await this.matches();
@@ -1686,27 +1827,58 @@ class Locator {
     return this.rt.span(`read.${name}`, run, { detail: () => ({ locator: this.toString() }) });
   }
   count() {
-    return this.traced("count", async () => (await this.matches()).entries.length);
+    return this.traced("count", async () => {
+      const { entries, react } = await this.conclusive();
+      return react?.length ?? entries.length;
+    });
   }
   async all() {
     const count = await this.count();
     return Array.from({ length: count }, (_, index) => this.nth(index));
   }
   text() {
-    return this.traced("text", async () => textOf((await this.single()).entry));
+    return this.traced("text", async () => {
+      const { entries, react, observed } = await this.conclusive();
+      if (react !== undefined)
+        return this.reactText(this.reactOnly(react, observed), observed);
+      if (entries.length === 0 && (await this.reactCandidates(observed)).length > 0) {
+        throw new E2eError2("NOT_ACTIONABLE", `${this} ${REACT_ONLY}`, this.rt.excerpt(observed.snapshot));
+      }
+      return textOf(this.exactlyOne(entries, observed));
+    });
   }
   allTexts() {
-    return this.traced("allTexts", async () => (await this.matches()).entries.map(textOf));
+    return this.traced("allTexts", async () => {
+      const { entries, react, observed } = await this.conclusive();
+      if (react !== undefined)
+        return react.map((match) => this.reactText(match, observed));
+      return entries.map(textOf);
+    });
+  }
+  reactText(match, observed) {
+    if (match.text !== undefined)
+      return normalizeText(match.text);
+    throw new E2eError2("NOT_ACTIONABLE", `${this} ${REACT_ONLY}`, this.rt.excerpt(observed.snapshot));
   }
   value() {
     return this.traced("value", async () => fieldValue((await this.single()).entry));
   }
   isVisible() {
-    return this.traced("isVisible", async () => this.visibleIn((await this.matches()).observed));
+    return this.traced("isVisible", async () => {
+      const { entries, react, observed } = await this.conclusive();
+      if (react !== undefined)
+        return reactVisible(this.reactOnly(react, observed), observed);
+      return entries.length > 0 && this.exactlyOne(entries, observed).visible;
+    });
   }
   read() {
     return this.traced("read", async () => {
-      const { entries, observed } = await this.matches();
+      const { entries, react, observed } = await this.conclusive();
+      if (react !== undefined) {
+        const match = this.reactOnly(react, observed);
+        const visible = reactVisible(match, observed);
+        return match.text === undefined ? { visible } : { visible, text: normalizeText(match.text) };
+      }
       if (entries.length === 0)
         return { visible: false };
       const entry = this.exactlyOne(entries, observed);
@@ -1718,11 +1890,13 @@ class Locator {
       };
     });
   }
-  visibleIn(observed) {
-    const entries = resolve(this.expr, observed.index);
-    if (entries.length === 0)
+  async shownIn(observed) {
+    const resolved = await this.resolveIn(observed);
+    if (resolved.kind === "unknown")
       return false;
-    return this.exactlyOne(entries, observed).visible;
+    if (resolved.kind === "react")
+      return reactVisible(this.reactOnly(resolved.matches, observed), observed);
+    return resolved.entries.length > 0 && this.exactlyOne(resolved.entries, observed).visible;
   }
   async isHidden() {
     return !await this.isVisible();
@@ -1735,7 +1909,7 @@ class Locator {
   }
   boundingBox() {
     return this.traced("boundingBox", async () => {
-      const { entries, observed } = await this.look({ reuse: false });
+      const { entries, observed } = await this.conclusive({ reuse: false });
       if (entries.length === 0) {
         const [only, ...others] = await this.reactCandidates(observed);
         if (only !== undefined && others.length === 0)
@@ -1762,14 +1936,19 @@ class Locator {
         return { done: false, state: undefined };
       }
       const { observed } = observation;
-      const entries = resolve(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 };
+      const resolved = await this.resolveIn(observed);
+      if (resolved.kind === "unknown")
+        return { done: false, state: { snapshot: observed.snapshot, degraded: resolved.read } };
+      const done = resolved.kind === "react" ? reachedByReact(state, reactVisible(this.reactOnly(resolved.matches, observed), observed)) : reached(state, resolved.entries.length === 0 ? undefined : this.exactlyOne(resolved.entries, observed));
+      return done ? { done: true, value: true } : { done: false, state: { snapshot: observed.snapshot } };
     }, timeoutMs);
     if (result.status === "done")
       return;
+    const last = result.last;
+    if (last?.degraded !== undefined)
+      throw this.degradedFailure(last.degraded, timeoutMs, last.snapshot);
     const message = `${this} did not become ${state} within ${timeoutMs} ms`;
-    throw new E2eError2("TIMEOUT", message, result.last === undefined ? undefined : this.rt.excerpt(result.last));
+    throw new E2eError2("TIMEOUT", message, last === undefined ? undefined : this.rt.excerpt(last.snapshot));
   }
   act(verb, run, suffix = "") {
     return this.rt.step(`${verb} ${this}${suffix}`, run);
@@ -1795,6 +1974,8 @@ class Locator {
     }
     if (seen?.kind === "driver")
       throw new E2eError2("DRIVER", `snapshot kept failing: ${seen.message}`);
+    if (seen?.kind === "degraded")
+      throw this.degradedFailure(seen.read, timeoutMs, seen.snapshot);
     throw new E2eError2("LOCATOR_NOT_FOUND", `${this} matched no elements within ${timeoutMs} ms`, seen === undefined ? undefined : this.rt.excerpt(seen.snapshot));
   }
   async actionableLook(spec, allowReact, anyFrame) {
@@ -1909,7 +2090,7 @@ class Locator {
       watch.unchanged = 0;
       return { done: false, state: undefined };
     }
-    if (until.visibleIn(observation.observed))
+    if (await until.shownIn(observation.observed))
       return { done: true, value: "arrived" };
     if (snapshotHash(observation.observed.snapshot) === watch.pressedOn)
       watch.unchanged += 1;
@@ -2034,10 +2215,17 @@ class Locator {
     return scrollUntilVisible(this.rt, this, options);
   }
   async reactStep(spec, observed, allowReact) {
-    const found = await this.reactCandidates(observed);
+    const read = degradedRead(observed.snapshot);
+    const testId = plainTestId(this.expr);
+    const lookup = testId === undefined ? undefined : await this.rt.reactLookup(testId, observed);
+    const found = lookup?.answered === true ? lookup.matches : [];
     const [match, ...others] = found;
-    if (match === undefined)
+    if (match === undefined) {
+      if (read !== undefined && lookup?.answered !== true) {
+        return { done: false, state: { kind: "degraded", read, snapshot: observed.snapshot } };
+      }
       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) {
@@ -2176,6 +2364,18 @@ function reached(state, entry) {
       return entry === undefined || !entry.visible;
   }
 }
+function reachedByReact(state, visible) {
+  switch (state) {
+    case "attached":
+      return true;
+    case "detached":
+      return false;
+    case "visible":
+      return visible;
+    case "hidden":
+      return !visible;
+  }
+}
 function blockedReason(entry, spec, observed) {
   if (!entry.visible)
     return "is not visible";
@@ -2189,7 +2389,11 @@ function blockedReason(entry, spec, observed) {
 function isOnScreenEntry(entry, observed) {
   return entry?.visible === true && isOnScreen(tapPointOf(entry), observed.snapshot.screen);
 }
-function scrollGaveUp(target, absent, effort, screen) {
+function scrollGaveUp(target, absent, effort, observed, waitedMs) {
+  const read = absent ? degradedRead(observed.snapshot) : undefined;
+  if (read !== undefined)
+    return target.degradedFailure(read, waitedMs, observed.snapshot);
+  const screen = target.runtime.excerpt(observed.snapshot);
   if (absent)
     return new E2eError2("LOCATOR_NOT_FOUND", `${target} was not found after ${effort}`, screen);
   return new E2eError2("NOT_ACTIONABLE", `${target} is still not on screen after ${effort}`, screen);
@@ -2218,7 +2422,8 @@ async function scrollUntilVisible(rt, target, options = {}) {
       if (isOnScreenEntry(entry, observed))
         return;
       if (swipes >= maxSwipes || budget.remaining() <= 0) {
-        throw scrollGaveUp(target, entry === undefined, `${swipes} swipes ${direction}`, rt.excerpt(observed.snapshot));
+        const effort = `${swipes} swipes ${direction}`;
+        throw scrollGaveUp(target, entry === undefined, effort, observed, budget.total);
       }
       await scrollOnce(rt, observed, direction, options.momentum);
       await observed.driver.settle(SCROLL_SETTLE);
@@ -4421,19 +4626,113 @@ function driverErr(code, message, extra) {
 }
 
 // ../../packages/e2e/src/driver/ios/simd-protocol.ts
+import { z as z7 } from "zod";
+
+// ../../packages/e2e/src/driver/bridge-stall.ts
 import { z as z6 } from "zod";
+var bridgeStallSchema = z6.looseObject({
+  stage: z6.string(),
+  readMs: z6.number().optional(),
+  deadlineMs: z6.number().optional(),
+  guestAgeMs: z6.number().optional(),
+  cold: z6.boolean(),
+  cooldownRemainingMs: z6.number().optional(),
+  probes: z6.number(),
+  recycles: z6.number().optional(),
+  recyclesExhausted: z6.boolean().optional()
+});
+var SPAN_FIELDS = [
+  ["stallStage", "stage"],
+  ["stallReadMs", "readMs"],
+  ["stallDeadlineMs", "deadlineMs"],
+  ["stallGuestAgeMs", "guestAgeMs"],
+  ["stallCold", "cold"],
+  ["stallCooldownMs", "cooldownRemainingMs"],
+  ["stallProbes", "probes"],
+  ["stallRecycles", "recycles"],
+  ["stallRecyclesExhausted", "recyclesExhausted"]
+];
+function toBridgeStall(wire) {
+  const stall = { stage: wire.stage, cold: wire.cold, probes: wire.probes };
+  if (wire.readMs !== undefined)
+    stall.readMs = wire.readMs;
+  if (wire.deadlineMs !== undefined)
+    stall.deadlineMs = wire.deadlineMs;
+  if (wire.guestAgeMs !== undefined)
+    stall.guestAgeMs = wire.guestAgeMs;
+  if (wire.cooldownRemainingMs !== undefined)
+    stall.cooldownRemainingMs = wire.cooldownRemainingMs;
+  if (wire.recycles !== undefined)
+    stall.recycles = wire.recycles;
+  if (wire.recyclesExhausted !== undefined)
+    stall.recyclesExhausted = wire.recyclesExhausted;
+  return stall;
+}
+function noteBridgeStall(stall) {
+  for (const [key, field] of SPAN_FIELDS) {
+    const value = stall[field];
+    if (value !== undefined)
+      noteSpanDetail(key, value);
+  }
+}
+function bridgeStallFromSpan(detail) {
+  const stage = detail?.stallStage;
+  if (detail === undefined || typeof stage !== "string")
+    return;
+  const stall = {
+    stage,
+    cold: detail.stallCold === true,
+    probes: typeof detail.stallProbes === "number" ? detail.stallProbes : 0
+  };
+  const numbers = [
+    ["stallReadMs", "readMs"],
+    ["stallDeadlineMs", "deadlineMs"],
+    ["stallGuestAgeMs", "guestAgeMs"],
+    ["stallCooldownMs", "cooldownRemainingMs"],
+    ["stallRecycles", "recycles"]
+  ];
+  for (const [key, field] of numbers) {
+    const value = detail[key];
+    if (typeof value === "number")
+      stall[field] = value;
+  }
+  if (typeof detail.stallRecyclesExhausted === "boolean")
+    stall.recyclesExhausted = detail.stallRecyclesExhausted;
+  return stall;
+}
+var seconds = (ms) => `${(ms / 1000).toFixed(1)} s`;
+function formatBridgeStall(stall) {
+  const parts = [`stage ${stall.stage}`];
+  if (stall.readMs !== undefined) {
+    parts.push(stall.deadlineMs === undefined ? `read ${stall.readMs} ms` : `read ${stall.readMs} ms of a ${stall.deadlineMs} ms deadline`);
+  } else if (stall.deadlineMs !== undefined)
+    parts.push(`${stall.deadlineMs} ms deadline`);
+  parts.push(stall.cold ? "cold (first read)" : "warm");
+  if (stall.guestAgeMs !== undefined)
+    parts.push(`guest ${seconds(stall.guestAgeMs)} old`);
+  if (stall.cooldownRemainingMs !== undefined)
+    parts.push(`cooldown ${seconds(stall.cooldownRemainingMs)} left`);
+  parts.push(`${stall.probes} failed bridge reads in a row`);
+  if (stall.recycles !== undefined) {
+    const guests = stall.recycles === 1 ? "guest" : "guests";
+    parts.push(`${stall.recycles} stalled ${guests} recycled${stall.recyclesExhausted === true ? ", none left" : ""}`);
+  }
+  return parts.join(" \xB7 ");
+}
+
+// ../../packages/e2e/src/driver/ios/simd-protocol.ts
 var protocolVersion = 1;
-var rectSchema2 = z6.object({
-  x: z6.number(),
-  y: z6.number(),
-  width: z6.number(),
-  height: z6.number()
+var rectSchema2 = z7.object({
+  x: z7.number(),
+  y: z7.number(),
+  width: z7.number(),
+  height: z7.number()
 });
-var screenInfoSchema = z6.object({
-  width: z6.number(),
-  height: z6.number(),
-  scale: z6.number(),
-  rotation: z6.number().optional()
+var screenInfoSchema = z7.object({
+  width: z7.number(),
+  height: z7.number(),
+  scale: z7.number(),
+  rotation: z7.number().optional()
 });
 var ROLES = [
   "button",
@@ -4460,29 +4759,29 @@ var ROLES = [
   "application",
   "other"
 ];
-var pointSchema = z6.object({ x: z6.number(), y: z6.number() });
-var wireElementSchema = z6.lazy(() => z6.object({
-  id: z6.string().nullish(),
-  role: z6.enum(ROLES),
-  rawType: z6.string(),
-  label: z6.string().nullish(),
-  identifier: z6.string().nullish(),
-  value: z6.string().nullish(),
-  text: z6.string().nullish(),
-  placeholder: z6.string().nullish(),
+var pointSchema = z7.object({ x: z7.number(), y: z7.number() });
+var wireElementSchema = z7.lazy(() => z7.object({
+  id: z7.string().nullish(),
+  role: z7.enum(ROLES),
+  rawType: z7.string(),
+  label: z7.string().nullish(),
+  identifier: z7.string().nullish(),
+  value: z7.string().nullish(),
+  text: z7.string().nullish(),
+  placeholder: z7.string().nullish(),
   frame: rectSchema2,
   normFrame: rectSchema2.nullish(),
-  traits: z6.array(z6.string()).nullish(),
-  enabled: z6.boolean().nullish(),
-  focused: z6.boolean().nullish(),
-  hidden: z6.boolean().nullish(),
-  selected: z6.boolean().nullish(),
-  checked: z6.boolean().nullish(),
-  hittable: z6.boolean().nullish(),
+  traits: z7.array(z7.string()).nullish(),
+  enabled: z7.boolean().nullish(),
+  focused: z7.boolean().nullish(),
+  hidden: z7.boolean().nullish(),
+  selected: z7.boolean().nullish(),
+  checked: z7.boolean().nullish(),
+  hittable: z7.boolean().nullish(),
   tapPoint: pointSchema.nullish(),
-  pid: z6.number().nullish(),
-  depth: z6.number().nullish(),
-  children: z6.array(wireElementSchema).nullish()
+  pid: z7.number().nullish(),
+  depth: z7.number().nullish(),
+  children: z7.array(wireElementSchema).nullish()
 }));
 var ROLE_SET = new Set(ROLES);
 var isBag = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -4520,33 +4819,33 @@ function wireElementProblem(value) {
   const issue = parsed.error.issues[0];
   return issue ? `${issue.path.join(".") || "(element)"}: ${issue.message}` : "invalid element";
 }
-var wireErrorSchema = z6.object({
-  code: z6.string(),
-  message: z6.string(),
-  retryable: z6.boolean().optional(),
-  detail: z6.unknown().optional()
+var wireErrorSchema = z7.object({
+  code: z7.string(),
+  message: z7.string(),
+  retryable: z7.boolean().optional(),
+  detail: z7.unknown().optional()
 });
-var readyEventSchema = z6.object({
-  event: z6.literal("ready"),
-  protocol: z6.number(),
-  version: z6.string(),
-  udid: z6.string(),
-  hid: z6.object({ transport: z6.string() }),
-  ax: z6.object({ default: z6.string(), bridge: z6.string() }),
+var readyEventSchema = z7.object({
+  event: z7.literal("ready"),
+  protocol: z7.number(),
+  version: z7.string(),
+  udid: z7.string(),
+  hid: z7.object({ transport: z7.string() }),
+  ax: z7.object({ default: z7.string(), bridge: z7.string() }),
   screen: screenInfoSchema
 });
-var logEventSchema = z6.object({
-  event: z6.literal("log"),
-  level: z6.enum(["debug", "info", "warn", "error"]),
-  message: z6.string(),
-  op: z6.string().optional(),
-  id: z6.string().optional()
+var logEventSchema = z7.object({
+  event: z7.literal("log"),
+  level: z7.enum(["debug", "info", "warn", "error"]),
+  message: z7.string(),
+  op: z7.string().optional(),
+  id: z7.string().optional()
 });
-var fatalEventSchema = z6.object({ event: z6.literal("fatal"), error: wireErrorSchema });
-var eventSchema = z6.discriminatedUnion("event", [readyEventSchema, logEventSchema, fatalEventSchema]);
-var responseSchema = z6.discriminatedUnion("ok", [
-  z6.object({ id: z6.string(), ok: z6.literal(true), data: z6.unknown().optional() }),
-  z6.object({ id: z6.string(), ok: z6.literal(false), error: wireErrorSchema })
+var fatalEventSchema = z7.object({ event: z7.literal("fatal"), error: wireErrorSchema });
+var eventSchema = z7.discriminatedUnion("event", [readyEventSchema, logEventSchema, fatalEventSchema]);
+var responseSchema = z7.discriminatedUnion("ok", [
+  z7.object({ id: z7.string(), ok: z7.literal(true), data: z7.unknown().optional() }),
+  z7.object({ id: z7.string(), ok: z7.literal(false), error: wireErrorSchema })
 ]);
 function parseLine(line) {
   let json;
@@ -4562,74 +4861,80 @@ function parseLine(line) {
   const response = responseSchema.safeParse(json);
   return response.success ? { success: true, message: { kind: "response", response: response.data } } : { success: false, reason: `bad response: ${response.error.message}` };
 }
-var healthDataSchema = z6.looseObject({
-  version: z6.string(),
-  udid: z6.string(),
-  hid: z6.object({ transport: z6.string() }),
-  ax: z6.object({
-    default: z6.string(),
-    bridge: z6.enum(["available", "degraded", "missing", "failed"]),
-    error: z6.string().optional(),
-    lastError: z6.object({ message: z6.string(), agoMs: z6.number() }).optional()
+var healthDataSchema = z7.looseObject({
+  version: z7.string(),
+  udid: z7.string(),
+  hid: z7.object({ transport: z7.string() }),
+  ax: z7.object({
+    default: z7.string(),
+    bridge: z7.enum(["available", "degraded", "missing", "failed"]),
+    error: z7.string().optional(),
+    lastError: z7.object({ message: z7.string(), agoMs: z7.number() }).optional()
   }),
   screen: screenInfoSchema,
-  socket: z6.object({ path: z6.string(), clients: z6.number() }).optional(),
-  idb: z6.string().optional(),
-  xcode: z6.string().optional(),
-  builtWith: z6.object({ xcode: z6.string().optional(), idb: z6.string().optional() }).optional(),
-  coreSimulatorVersion: z6.string().nullish(),
-  frontmost: z6.object({ unresolvedAgoMs: z6.number(), method: z6.string() }).optional(),
-  state: z6.string().optional(),
-  uptimeMs: z6.number().optional()
+  socket: z7.object({ path: z7.string(), clients: z7.number() }).optional(),
+  idb: z7.string().optional(),
+  xcode: z7.string().optional(),
+  builtWith: z7.object({ xcode: z7.string().optional(), idb: z7.string().optional() }).optional(),
+  coreSimulatorVersion: z7.string().nullish(),
+  frontmost: z7.object({ unresolvedAgoMs: z7.number(), method: z7.string() }).optional(),
+  bridgeRecycles: z7.object({ count: z7.number(), exhausted: z7.boolean() }).optional(),
+  state: z7.string().optional(),
+  uptimeMs: z7.number().optional()
 });
-var snapshotDataSchema = z6.looseObject({
-  backend: z6.enum(["axbridge", "ax", "uiautomator"]),
+var snapshotDataSchema = z7.looseObject({
+  backend: z7.enum(["axbridge", "ax", "uiautomator"]),
   screen: screenInfoSchema,
-  modal: z6.object({ pid: z6.number().optional(), description: z6.string().optional() }).nullish(),
-  truncated: z6.boolean(),
-  elements: z6.array(z6.custom(isWireElement, { error: (issue) => wireElementProblem(issue.input) })),
-  ms: z6.number(),
-  fallback: z6.object({ from: z6.string(), to: z6.string(), reason: z6.string() }).optional(),
-  target: z6.object({ pid: z6.number(), source: z6.string() }).optional(),
-  readMs: z6.number().optional(),
-  nodes: z6.number().optional()
+  modal: z7.object({ pid: z7.number().optional(), description: z7.string().optional() }).nullish(),
+  truncated: z7.boolean(),
+  elements: z7.array(z7.custom(isWireElement, { error: (issue) => wireElementProblem(issue.input) })),
+  ms: z7.number(),
+  fallback: z7.object({
+    from: z7.string(),
+    to: z7.string(),
+    reason: z7.string(),
+    stall: bridgeStallSchema.optional()
+  }).optional(),
+  target: z7.object({ pid: z7.number(), source: z7.string() }).optional(),
+  readMs: z7.number().optional(),
+  nodes: z7.number().optional()
 });
 var elementAtPointDataSchema = wireElementSchema.nullable();
-var screenshotDataSchema = z6.looseObject({
-  path: z6.string().optional(),
-  png: z6.string().optional(),
-  width: z6.number().optional(),
-  height: z6.number().optional()
+var screenshotDataSchema = z7.looseObject({
+  path: z7.string().optional(),
+  png: z7.string().optional(),
+  width: z7.number().optional(),
+  height: z7.number().optional()
 });
-var settleDataSchema = z6.looseObject({
-  quiet: z6.boolean(),
-  waitedMs: z6.number(),
-  via: z6.enum(["stream", "snapshot"]).optional().catch(undefined),
-  reason: z6.string().optional(),
-  frontmostPid: z6.number().optional()
+var settleDataSchema = z7.looseObject({
+  quiet: z7.boolean(),
+  waitedMs: z7.number(),
+  via: z7.enum(["stream", "snapshot"]).optional().catch(undefined),
+  reason: z7.string().optional(),
+  frontmostPid: z7.number().optional()
 });
-var rebindDataSchema = z6.looseObject({
-  bound: z6.boolean(),
-  waitedMs: z6.number(),
-  pid: z6.number().optional(),
-  restarts: z6.number().optional(),
-  recycled: z6.boolean().optional(),
-  reason: z6.string().optional()
+var rebindDataSchema = z7.looseObject({
+  bound: z7.boolean(),
+  waitedMs: z7.number(),
+  pid: z7.number().optional(),
+  restarts: z7.number().optional(),
+  recycled: z7.boolean().optional(),
+  reason: z7.string().optional()
 });
-var alertButtonsDataSchema = z6.object({
-  title: z6.string().optional(),
-  message: z6.string().optional(),
-  buttons: z6.array(wireElementSchema)
+var alertButtonsDataSchema = z7.object({
+  title: z7.string().optional(),
+  message: z7.string().optional(),
+  buttons: z7.array(wireElementSchema)
 }).nullable();
-var frontmostDataSchema = z6.looseObject({
-  frontmost: z6.boolean(),
-  pid: z6.number().optional(),
-  frontmostPid: z6.number().optional()
+var frontmostDataSchema = z7.looseObject({
+  frontmost: z7.boolean(),
+  pid: z7.number().optional(),
+  frontmostPid: z7.number().optional()
 });
-var launchDataSchema = z6.looseObject({ pid: z6.number() });
-var terminateDataSchema = z6.looseObject({ terminated: z6.boolean() });
-var orientationDataSchema = z6.object({
-  orientation: z6.enum([
+var launchDataSchema = z7.looseObject({ pid: z7.number() });
+var terminateDataSchema = z7.looseObject({ terminated: z7.boolean() });
+var orientationDataSchema = z7.object({
+  orientation: z7.enum([
     "portrait",
     "portraitUpsideDown",
     "landscapeLeft",
@@ -4638,7 +4943,7 @@ var orientationDataSchema = z6.object({
     "faceDown",
     "unknown"
   ]),
-  source: z6.enum(["device", "written", "assumed"]).optional()
+  source: z7.enum(["device", "written", "assumed"]).optional()
 });
 var opSchemas = {
   health: healthDataSchema,
@@ -5079,7 +5384,7 @@ async function createSimdClient(factory, options = {}) {
     const transport = session.data.transport;
     if (!transport)
       return { success: false, error: driverError("E_INTERNAL", "warden-simd transport missing") };
-    const timeoutMs = opts.timeoutMs ?? defaultTimeoutMs;
+    const timeoutMs = Math.max(opts.timeoutMs ?? defaultTimeoutMs, opts.minTimeoutMs ?? 0);
     const id = String(++seq);
     const result = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -5342,7 +5647,7 @@ function traceDriver(driver, options) {
 }
 
 // ../../packages/core/src/a11y/a11y.config.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var A11Y_RULE_IDS = [
   "missing-name",
   "image-no-name",
@@ -5355,11 +5660,11 @@ var A11Y_RULE_IDS = [
   "text-clipped",
   "native"
 ];
-var ruleId = z7.enum(A11Y_RULE_IDS);
-var a11yAuditConfigSchema = z7.object({
-  ignore: z7.array(z7.object({ rule: ruleId, identifier: z7.string().min(1).optional() }).strict()).optional(),
-  minSeverity: z7.enum(["error", "warning"]).optional(),
-  rules: z7.array(ruleId).min(1).optional()
+var ruleId = z8.enum(A11Y_RULE_IDS);
+var a11yAuditConfigSchema = z8.object({
+  ignore: z8.array(z8.object({ rule: ruleId, identifier: z8.string().min(1).optional() }).strict()).optional(),
+  minSeverity: z8.enum(["error", "warning"]).optional(),
+  rules: z8.array(ruleId).min(1).optional()
 }).strict();
 function parseA11yAuditEnv(raw) {
   let json;
@@ -5375,7 +5680,7 @@ function parseA11yAuditEnv(raw) {
 }
 
 // ../../packages/core/src/conditions/conditions.config.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../../packages/core/src/duration.ts
 var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
@@ -5536,51 +5841,51 @@ function appliedA11y(op, applied) {
 
 // ../../packages/core/src/conditions/conditions.config.ts
 var NETWORK_WORDS = ["online", "offline", ...NETWORK_PRESET_NAMES];
-var nonNegative2 = z8.number().nonnegative().finite();
-var customNetworkSchema = z8.object({
+var nonNegative2 = z9.number().nonnegative().finite();
+var customNetworkSchema = z9.object({
   latencyMs: nonNegative2.optional(),
   jitterMs: nonNegative2.optional(),
   downKbps: nonNegative2.optional(),
   upKbps: nonNegative2.optional(),
-  lossPct: z8.number().min(0).max(100).optional()
+  lossPct: z9.number().min(0).max(100).optional()
 }).strict();
-var isoDate = z8.string().refine((v) => !Number.isNaN(Date.parse(v)), { message: "invalid date (use ISO 8601)" });
-var offsetDuration = z8.string().refine((v) => parseDuration(v).success, { message: "invalid duration (use e.g. 2d)" });
-var textSize = z8.union([z8.enum(TEXT_SIZE_NAMES), z8.number().positive().finite()]);
-var a11yConfigSchema = z8.object({
+var isoDate = z9.string().refine((v) => !Number.isNaN(Date.parse(v)), { message: "invalid date (use ISO 8601)" });
+var offsetDuration = z9.string().refine((v) => parseDuration(v).success, { message: "invalid duration (use e.g. 2d)" });
+var textSize = z9.union([z9.enum(TEXT_SIZE_NAMES), z9.number().positive().finite()]);
+var a11yConfigSchema = z9.object({
   textSize: textSize.optional(),
-  boldText: z8.boolean().optional(),
-  contrast: z8.enum(["increased", "normal"]).optional(),
-  reduceMotion: z8.boolean().optional()
+  boldText: z9.boolean().optional(),
+  contrast: z9.enum(["increased", "normal"]).optional(),
+  reduceMotion: z9.boolean().optional()
 }).strict();
-var conditionsConfigSchema = z8.object({
-  network: z8.union([z8.enum(NETWORK_WORDS), customNetworkSchema]).optional(),
-  location: z8.union([
-    z8.enum(["city-run", "city-bike", "freeway"]),
-    z8.object({
-      lat: z8.number().min(-90).max(90),
-      lon: z8.number().min(-180).max(180),
-      altM: z8.number().finite().optional()
+var conditionsConfigSchema = z9.object({
+  network: z9.union([z9.enum(NETWORK_WORDS), customNetworkSchema]).optional(),
+  location: z9.union([
+    z9.enum(["city-run", "city-bike", "freeway"]),
+    z9.object({
+      lat: z9.number().min(-90).max(90),
+      lon: z9.number().min(-180).max(180),
+      altM: z9.number().finite().optional()
     }).strict()
   ]).optional(),
-  clock: z8.union([
+  clock: z9.union([
     isoDate,
-    z8.object({ at: isoDate, frozen: z8.boolean().optional() }).strict(),
-    z8.object({ offset: offsetDuration }).strict()
+    z9.object({ at: isoDate, frozen: z9.boolean().optional() }).strict(),
+    z9.object({ offset: offsetDuration }).strict()
   ]).optional(),
-  permissions: z8.partialRecord(z8.enum(PERMISSION_NAMES), z8.enum(["granted", "denied", "unset"])).optional(),
-  locale: z8.string().min(1).optional(),
-  timezone: z8.string().min(1).optional(),
+  permissions: z9.partialRecord(z9.enum(PERMISSION_NAMES), z9.enum(["granted", "denied", "unset"])).optional(),
+  locale: z9.string().min(1).optional(),
+  timezone: z9.string().min(1).optional(),
   a11y: a11yConfigSchema.optional()
 }).strict();
-var cameraFeedInput = z8.union([
-  z8.string().min(1),
-  z8.object({ path: z8.string().min(1), loop: z8.boolean().optional() }).strict()
+var cameraFeedInput = z9.union([
+  z9.string().min(1),
+  z9.object({ path: z9.string().min(1), loop: z9.boolean().optional() }).strict()
 ]);
-var cameraConfigSchema = z8.object({ back: cameraFeedInput.optional(), front: cameraFeedInput.optional() }).strict().refine((v) => v.back !== undefined || v.front !== undefined, { message: "camera needs a back or a front asset" });
-var cameraFeedsSchema = z8.object({
-  back: z8.object({ path: z8.string().min(1), loop: z8.boolean() }).strict().optional(),
-  front: z8.object({ path: z8.string().min(1), loop: z8.boolean() }).strict().optional()
+var cameraConfigSchema = z9.object({ back: cameraFeedInput.optional(), front: cameraFeedInput.optional() }).strict().refine((v) => v.back !== undefined || v.front !== undefined, { message: "camera needs a back or a front asset" });
+var cameraFeedsSchema = z9.object({
+  back: z9.object({ path: z9.string().min(1), loop: z9.boolean() }).strict().optional(),
+  front: z9.object({ path: z9.string().min(1), loop: z9.boolean() }).strict().optional()
 }).strict();
 function parseCameraFeedsEnv(raw) {
   let json;
@@ -5662,7 +5967,7 @@ function parseConditionsEnv(raw) {
 }
 
 // ../../packages/e2e/src/env.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var ENV_NAMES = {
   udid: "WARDEN_UDID",
   deviceName: "WARDEN_DEVICE_NAME",
@@ -5700,68 +6005,68 @@ var ENV_NAMES = {
 var DEFAULT_TIMEOUT_MS5 = 120000;
 var DEFAULT_ACTION_TIMEOUT_MS = 30000;
 var DEFAULT_ASSERTION_TIMEOUT_MS = 5000;
-var toggle = z9.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
-var millis = z9.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z9.number().int().positive());
-var launchArgs = z9.string().transform((raw, ctx) => {
+var toggle = z10.enum(["1", "true", "0", "false"]).transform((v) => v === "1" || v === "true");
+var millis = z10.string().regex(/^\d+$/, "must be a whole number of milliseconds").transform(Number).pipe(z10.number().int().positive());
+var launchArgs = z10.string().transform((raw, ctx) => {
   try {
-    const parsed = z9.array(z9.string()).safeParse(JSON.parse(raw));
+    const parsed = z10.array(z10.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 z9.NEVER;
+  return z10.NEVER;
 });
-var conditions = z9.string().transform((raw, ctx) => {
+var conditions = z10.string().transform((raw, ctx) => {
   const parsed = parseConditionsEnv(raw);
   if (parsed.success)
     return parsed.data;
   ctx.addIssue({ code: "custom", message: parsed.error });
-  return z9.NEVER;
+  return z10.NEVER;
 });
-var a11yAudit = z9.string().transform((raw, ctx) => {
+var a11yAudit = z10.string().transform((raw, ctx) => {
   const parsed = parseA11yAuditEnv(raw);
   if (parsed.success)
     return parsed.data;
   ctx.addIssue({ code: "custom", message: parsed.error });
-  return z9.NEVER;
+  return z10.NEVER;
 });
-var cameraFeeds = z9.string().transform((raw, ctx) => {
+var cameraFeeds = z10.string().transform((raw, ctx) => {
   const parsed = parseCameraFeedsEnv(raw);
   if (parsed.success)
     return parsed.data;
   ctx.addIssue({ code: "custom", message: parsed.error });
-  return z9.NEVER;
+  return z10.NEVER;
 });
 var REQUIRED = "required when WARDEN_UDID is set";
-var schema = z9.object({
-  udid: z9.string().min(1),
-  deviceName: z9.string().optional(),
-  platform: z9.enum(["ios", "android"]).default("ios"),
-  bundleId: z9.string({ error: REQUIRED }).min(1, REQUIRED),
-  appPath: z9.string().optional(),
-  metroUrl: z9.string().optional(),
-  devClientScheme: z9.string().min(1).optional(),
+var schema = z10.object({
+  udid: z10.string().min(1),
+  deviceName: z10.string().optional(),
+  platform: z10.enum(["ios", "android"]).default("ios"),
+  bundleId: z10.string({ error: REQUIRED }).min(1, REQUIRED),
+  appPath: z10.string().optional(),
+  metroUrl: z10.string().optional(),
+  devClientScheme: z10.string().min(1).optional(),
   launchArgs: launchArgs.default([]),
-  out: z9.string().optional(),
+  out: z10.string().optional(),
   timeout: millis.default(DEFAULT_TIMEOUT_MS5),
   actionTimeout: millis.default(DEFAULT_ACTION_TIMEOUT_MS),
   assertionTimeout: millis.default(DEFAULT_ASSERTION_TIMEOUT_MS),
-  specsDir: z9.string().optional(),
-  helperDir: z9.string().optional(),
-  simd: z9.string().optional(),
-  simdSocket: z9.string().optional(),
-  iosRunnerSocket: z9.string().optional(),
+  specsDir: z10.string().optional(),
+  helperDir: z10.string().optional(),
+  simd: z10.string().optional(),
+  simdSocket: z10.string().optional(),
+  iosRunnerSocket: z10.string().optional(),
   logTimestamps: toggle.default(false),
-  deviceKind: z9.enum(["physical"]).optional(),
+  deviceKind: z10.enum(["physical"]).optional(),
   iosRunnerRestart: launchArgs.optional(),
   afterReboot: launchArgs.optional(),
-  version: z9.string().optional(),
-  bin: z9.string().optional(),
-  perf: z9.string().optional(),
-  perfBudgets: z9.string().optional(),
+  version: z10.string().optional(),
+  bin: z10.string().optional(),
+  perf: z10.string().optional(),
+  perfBudgets: z10.string().optional(),
   conditions: conditions.optional(),
-  leaseId: z9.string().min(1).optional(),
-  netproxyCommand: launchArgs.pipe(z9.array(z9.string()).min(1)).optional(),
+  leaseId: z10.string().min(1).optional(),
+  netproxyCommand: launchArgs.pipe(z10.array(z10.string()).min(1)).optional(),
   biometrics: toggle.optional(),
   a11yAudit: a11yAudit.optional(),
   cameraFeeds: cameraFeeds.optional()
@@ -5771,7 +6076,7 @@ function defined2(values) {
 }
 function parseArgv(raw) {
   try {
-    const parsed = z9.array(z9.string()).min(1).safeParse(JSON.parse(raw));
+    const parsed = z10.array(z10.string()).min(1).safeParse(JSON.parse(raw));
     if (parsed.success)
       return parsed.data;
   } catch {}
@@ -5841,25 +6146,43 @@ function readEnv(env, opts = {}) {
 // ../../packages/e2e/src/runner/results.ts
 import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname3 } from "path";
-import { z as z10 } from "zod";
-var testStatusSchema = z10.enum(["passed", "failed", "skipped", "timed-out"]);
-var testResultSchema = z10.object({
-  file: z10.string(),
-  title: z10.array(z10.string()),
+import { z as z11 } from "zod";
+var bridgeReadSchema = z11.object({
+  reason: z11.string().optional(),
+  code: z11.string().optional(),
+  stage: z11.string().optional(),
+  readMs: z11.number().optional(),
+  deadlineMs: z11.number().optional(),
+  guestAgeMs: z11.number().optional(),
+  cold: z11.boolean().optional(),
+  cooldownRemainingMs: z11.number().optional(),
+  probes: z11.number().optional(),
+  recycles: z11.number().optional(),
+  recyclesExhausted: z11.boolean().optional()
+});
+var testStatusSchema = z11.enum(["passed", "failed", "skipped", "timed-out"]);
+var testResultSchema = z11.object({
+  file: z11.string(),
+  title: z11.array(z11.string()),
   status: testStatusSchema,
-  durationMs: z10.number(),
-  startedAt: z10.number(),
-  only: z10.boolean().optional(),
-  error: z10.object({
-    message: z10.string(),
-    code: z10.string().optional(),
-    stack: z10.string().optional()
+  durationMs: z11.number(),
+  startedAt: z11.number(),
+  only: z11.boolean().optional(),
+  error: z11.object({
+    message: z11.string(),
+    code: z11.string().optional(),
+    stack: z11.string().optional()
+  }).optional(),
+  artifacts: z11.object({ dir: z11.string(), files: z11.array(z11.string()) }).optional(),
+  bridge: z11.object({
+    fallbacks: z11.number(),
+    first: bridgeReadSchema,
+    last: bridgeReadSchema
   }).optional(),
-  artifacts: z10.object({ dir: z10.string(), files: z10.array(z10.string()) }).optional(),
-  device: z10.object({
-    udid: z10.string(),
-    platform: z10.enum(["ios", "android"]),
-    name: z10.string().optional()
+  device: z11.object({
+    udid: z11.string(),
+    platform: z11.enum(["ios", "android"]),
+    name: z11.string().optional()
   })
 });
 function openResults(path) {
@@ -9327,6 +9650,6 @@ function onlyWasSeen() {
 
 // ../../packages/e2e/src/version.ts
 var WORKSPACE_VERSION = "0.0.0-workspace";
-var WARDEN_E2E_VERSION2 = "0.13.0";
+var WARDEN_E2E_VERSION2 = "0.14.0";
 
-export { E2eError2, registerA11yTarget, a11yTargetOf, canActOnElements, noteSpanDetail, addSpanDetail, canObserve, canDetectAlerts, settleDetailOf, DEFAULT_SETTLE_QUIET_MS, DEFAULT_SETTLE_TIMEOUT_MS, settleByHash, snapshotHash, ok, err, swipeVector, screenRect, fieldValue, PINCH_MS, ROTATE_MS, PATH_MS, centreOf, pinchRadius, rotateRadius, requireGesture, assertScale, assertDegrees, isInteractiveRole, resolveRole, normalizeText, matchesText, indexSnapshot, testIdQuery, textQuery, roleQuery, selectorExpression, renderSnapshot, renderHeader, resolve, locateByTestIdViaReact, isLocator, Locator, pickOne, textOf, scrollUntilVisible, formatNativeTail, realNativeLogDeps, captureNativeLog, bunExec, execError, driverError, driverErr, logEventSchema, fatalEventSchema, responseSchema, mapWireError, createLineSplitter, encodeRequest, bunSpawn, stdioTransport, socketTransport, createSimdClient, spawnSimd, connectSimd, isRecoverableLoss, parseDuration, CAMERA_FACINGS, CONDITION_AREAS, resolveNetwork, resolveTextSize, androidFontScale, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, peekSession, accessibleName, announce, failing, formatIssues, toE2eError, settled, unwrap, parseUiadA11yEvents, parseInjectEvents, withA11yRead, renderA11yScreen, createDeviceA11y, IOS_DEVICE_CAPABILITIES, sniffCameraMedia, cameraFeedDir, clearCameraFeeds, isLeaseAlive, processAlive, describeOwner, isPhysicalIosId, wardenHome, defaultDbPath, ownerKey, openStore, callerFile, formatCoord, DEFAULT_SPEED_MPS, DEFAULT_INTERVAL_S, realTickerClock, startRouteTicker, startFlap, registerConditions, conditionsOf, conditionSinkFor, createDeviceConditions, parseBudgets, createDevicePerf, perfStartFor, spawnWarden, hash6, attemptDir, screenshotPath, specIdOf, BUN_TIMEOUT_MARGIN_MS2, ownHook, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION2 };
+export { E2eError2, registerA11yTarget, a11yTargetOf, canActOnElements, noteSpanDetail, addSpanDetail, canObserve, canDetectAlerts, settleDetailOf, DEFAULT_SETTLE_QUIET_MS, DEFAULT_SETTLE_TIMEOUT_MS, hashFallbackQuietMs, settleByHash, snapshotHash, ok, err, swipeVector, screenRect, isOnScreen, fieldValue, PINCH_MS, ROTATE_MS, PATH_MS, centreOf, pinchRadius, rotateRadius, requireGesture, assertScale, assertDegrees, isInteractiveRole, resolveRole, normalizeText, matchesText, indexSnapshot, testIdQuery, textQuery, roleQuery, selectorExpression, renderSnapshot, renderHeader, lookUpTestIdViaReact, isLocator, Locator, pickOne, textOf, scrollUntilVisible, formatNativeTail, realNativeLogDeps, captureNativeLog, bunExec, execError, driverError, driverErr, bridgeStallSchema, toBridgeStall, noteBridgeStall, bridgeStallFromSpan, formatBridgeStall, logEventSchema, fatalEventSchema, responseSchema, mapWireError, createLineSplitter, encodeRequest, bunSpawn, stdioTransport, socketTransport, createSimdClient, spawnSimd, connectSimd, isRecoverableLoss, parseDuration, CAMERA_FACINGS, CONDITION_AREAS, resolveNetwork, resolveTextSize, androidFontScale, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, peekSession, accessibleName, announce, failing, formatIssues, toE2eError, settled, unwrap, parseUiadA11yEvents, parseInjectEvents, withA11yRead, renderA11yScreen, createDeviceA11y, IOS_DEVICE_CAPABILITIES, sniffCameraMedia, cameraFeedDir, clearCameraFeeds, isLeaseAlive, processAlive, describeOwner, isPhysicalIosId, wardenHome, defaultDbPath, ownerKey, openStore, callerFile, formatCoord, DEFAULT_SPEED_MPS, DEFAULT_INTERVAL_S, realTickerClock, startRouteTicker, startFlap, registerConditions, conditionsOf, conditionSinkFor, createDeviceConditions, parseBudgets, createDevicePerf, perfStartFor, spawnWarden, hash6, attemptDir, screenshotPath, specIdOf, BUN_TIMEOUT_MARGIN_MS2, ownHook, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION2 };