sootsim 0.1.83 → 0.1.84

package/dist-lib/detox/index.cjs

@@ -0,0 +1,1770 @@
+/*! sootsim v0.1.84 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// detox/index.ts
+var detox_exports = {};
+__export(detox_exports, {
+  by: () => by,
+  cleanup: () => cleanup,
+  device: () => device,
+  element: () => element,
+  expect: () => sootExpect,
+  waitFor: () => sootWaitFor
+});
+module.exports = __toCommonJS(detox_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_playwright = require("playwright");
+
+// detox/gestures.ts
+async function waitForSootsimGestureHandler(page, viewTag, handlerName) {
+  await page.waitForFunction(
+    async ({ viewTag: viewTag2, handlerName: handlerName2 }) => {
+      const host = window.SootSim?.bridges?.shellHost;
+      if (typeof host?.callTestBridge !== "function") return false;
+      let debug = null;
+      try {
+        debug = await host.callTestBridge("getShellGestureSeamDebug");
+      } catch {
+        return false;
+      }
+      return debug?.attached?.some(
+        (entry) => entry.viewTag === viewTag2 && entry.nodeFound !== false && entry.handlers?.some((handler) => handler.name === handlerName2)
+      ) === true;
+    },
+    { viewTag, handlerName },
+    { timeout: 5e3 }
+  );
+}
+async function readWorkletCallbackStats(page) {
+  return page.evaluate(async () => {
+    const g = window;
+    const tenant = typeof g.__sootsimTest?.getWorkletSlotStats === "function" ? await g.__sootsimTest.getWorkletSlotStats() : null;
+    const shellHost = g.SootSim?.bridges?.shellHost;
+    let shell = null;
+    if (typeof shellHost?.callTestBridge === "function") {
+      try {
+        shell = await shellHost.callTestBridge("getWorkletSlotStats");
+      } catch {
+      }
+    }
+    const tenantReceived = typeof tenant?.runJSCallbackReceived === "number" ? tenant.runJSCallbackReceived : 0;
+    const shellSent = typeof shell?.runJSCallbackSent === "number" ? shell.runJSCallbackSent : 0;
+    return { tenantReceived, shellSent };
+  });
+}
+async function waitForWorkletCallbackDrain(page, before) {
+  if (!before) {
+    await page.waitForTimeout(250);
+    return;
+  }
+  const deadline = Date.now() + 1500;
+  let lastShellSent = before.shellSent;
+  let stableSince = Date.now();
+  let sawCallback = false;
+  while (Date.now() < deadline) {
+    const current = await readWorkletCallbackStats(page);
+    if (!current) {
+      await page.waitForTimeout(20);
+      continue;
+    }
+    if (current.shellSent !== lastShellSent) {
+      lastShellSent = current.shellSent;
+      stableSince = Date.now();
+    }
+    const sentDelta = current.shellSent - before.shellSent;
+    if (sentDelta > 0) sawCallback = true;
+    const receivedDelta = current.tenantReceived - before.tenantReceived;
+    if (sawCallback && receivedDelta >= sentDelta && Date.now() - stableSince >= 100) {
+      return;
+    }
+    await page.waitForTimeout(20);
+  }
+  if (!sawCallback) {
+    await page.waitForTimeout(250);
+  }
+}
+var sootsimCanvasFinderInstalled = /* @__PURE__ */ new WeakSet();
+function installInteractiveCanvasFinder() {
+  window.__sootsimFindInteractiveCanvas = () => {
+    const interactive = [];
+    const appVisible = [];
+    for (const c of Array.from(document.querySelectorAll("canvas"))) {
+      const s = window.getComputedStyle(c);
+      if (s.display === "none" || s.visibility === "hidden") continue;
+      const r = c.getBoundingClientRect();
+      if (r.width === 0 || r.height === 0) continue;
+      const entry = {
+        c,
+        z: parseInt(s.zIndex, 10) || 0,
+        app: c.dataset.surfaceId?.startsWith("app:") === true
+      };
+      if (entry.app) appVisible.push(entry);
+      if (s.pointerEvents !== "none") interactive.push(entry);
+    }
+    const list = appVisible.length > 0 ? appVisible : interactive;
+    if (list.length === 0) return null;
+    list.sort((a, b) => Number(b.app) - Number(a.app) || b.z - a.z);
+    return list[0].c;
+  };
+}
+async function ensureCanvasFinder(page) {
+  if (!sootsimCanvasFinderInstalled.has(page)) {
+    sootsimCanvasFinderInstalled.add(page);
+    await page.addInitScript(installInteractiveCanvasFinder);
+  }
+  await page.evaluate(installInteractiveCanvasFinder);
+}
+async function readSootsimPageMetrics(page) {
+  await ensureCanvasFinder(page);
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    const metrics = await page.evaluate(async () => {
+      const canvas = window.__sootsimFindInteractiveCanvas?.() ?? document.querySelector("canvas");
+      if (!canvas) return null;
+      const rect = canvas.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) return null;
+      const surface = await window.__sootsimTest?.getSurfaceMetricsSnapshot?.();
+      const screenWidth = surface?.window?.width;
+      const screenHeight = surface?.window?.height;
+      if (typeof screenWidth !== "number" || typeof screenHeight !== "number" || screenWidth <= 0 || screenHeight <= 0) {
+        return null;
+      }
+      const homeIndicatorHeight = Number(surface?.device?.homeIndicatorHeight) || 0;
+      const safeAreaBottom = Number(surface?.safeAreaInsets?.bottom) || 0;
+      const bottomInset = Math.max(0, homeIndicatorHeight, safeAreaBottom);
+      const visibleRectBottom = Number(surface?.visibleRect?.y) + Number(surface?.visibleRect?.height);
+      const interactiveHeight = Number.isFinite(visibleRectBottom) && visibleRectBottom > 0 ? Math.min(screenHeight, visibleRectBottom) : Math.max(0, screenHeight - bottomInset);
+      return {
+        canvas: {
+          left: rect.left,
+          top: rect.top,
+          width: rect.width,
+          height: rect.height
+        },
+        window: {
+          width: screenWidth,
+          height: screenHeight
+        },
+        interactiveWindow: {
+          width: screenWidth,
+          height: interactiveHeight
+        }
+      };
+    });
+    if (metrics) return metrics;
+    await page.waitForTimeout(50);
+  }
+  throw new Error("sootsim surface metrics are not available");
+}
+async function readSootsimInteractiveViewport(page) {
+  return (await readSootsimPageMetrics(page)).interactiveWindow;
+}
+async function sootsimToPage(page, sootX, sootY) {
+  const metrics = await readSootsimPageMetrics(page);
+  const scaleX = metrics.canvas.width / metrics.window.width;
+  const scaleY = metrics.canvas.height / metrics.window.height;
+  return {
+    x: metrics.canvas.left + sootX * scaleX,
+    y: metrics.canvas.top + sootY * scaleY
+  };
+}
+async function dragScrollNode(page, node, pixels, direction) {
+  const startSootX = node.absolutePosition.x + node.layout.width / 2;
+  const startSootY = node.absolutePosition.y + node.layout.height / 2;
+  let endSootX = startSootX;
+  let endSootY = startSootY;
+  switch (direction) {
+    case "down":
+      endSootY -= pixels;
+      break;
+    case "up":
+      endSootY += pixels;
+      break;
+    case "left":
+      endSootX += pixels;
+      break;
+    case "right":
+      endSootX -= pixels;
+      break;
+  }
+  const startPage = await sootsimToPage(page, startSootX, startSootY);
+  const endPage = await sootsimToPage(page, endSootX, endSootY);
+  const steps = 12;
+  await page.mouse.move(startPage.x, startPage.y);
+  await page.mouse.down();
+  await page.waitForTimeout(20);
+  const dx = (endPage.x - startPage.x) / steps;
+  const dy = (endPage.y - startPage.y) / steps;
+  for (let i = 1; i <= steps; i++) {
+    await page.mouse.move(startPage.x + dx * i, startPage.y + dy * i);
+    await page.waitForTimeout(16);
+  }
+  await page.mouse.up();
+  await page.waitForTimeout(180);
+}
+async function dispatchTwoFingerGesture(page, startA, startB, endA, endB, options = {}) {
+  const steps = options.steps ?? 10;
+  const stepDelay = options.stepDelayMs ?? 18;
+  await ensureCanvasFinder(page);
+  const beforeWorkletStats = await readWorkletCallbackStats(page);
+  await page.evaluate(
+    ({ startA: startA2, startB: startB2 }) => {
+      const canvas = window.__sootsimFindInteractiveCanvas?.() ?? document.querySelector("canvas");
+      if (!canvas) throw new Error("sootsim interactive canvas not found");
+      const fire = (point, id, primary) => {
+        canvas.dispatchEvent(
+          new PointerEvent("pointerdown", {
+            bubbles: true,
+            cancelable: true,
+            clientX: point.x,
+            clientY: point.y,
+            isPrimary: primary,
+            pointerId: id,
+            pointerType: "touch"
+          })
+        );
+      };
+      fire(startA2, 1001, true);
+      fire(startB2, 1002, false);
+    },
+    { startA, startB }
+  );
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps;
+    const ax = startA.x + (endA.x - startA.x) * t;
+    const ay = startA.y + (endA.y - startA.y) * t;
+    const bx = startB.x + (endB.x - startB.x) * t;
+    const by2 = startB.y + (endB.y - startB.y) * t;
+    await page.evaluate(
+      ({ ax: ax2, ay: ay2, bx: bx2, by: by3 }) => {
+        const canvas = window.__sootsimFindInteractiveCanvas?.() ?? document.querySelector("canvas");
+        if (!canvas) return;
+        canvas.dispatchEvent(
+          new PointerEvent("pointermove", {
+            bubbles: true,
+            cancelable: true,
+            clientX: ax2,
+            clientY: ay2,
+            isPrimary: true,
+            pointerId: 1001,
+            pointerType: "touch"
+          })
+        );
+        canvas.dispatchEvent(
+          new PointerEvent("pointermove", {
+            bubbles: true,
+            cancelable: true,
+            clientX: bx2,
+            clientY: by3,
+            isPrimary: false,
+            pointerId: 1002,
+            pointerType: "touch"
+          })
+        );
+      },
+      { ax, ay, bx, by: by2 }
+    );
+    await page.waitForTimeout(stepDelay);
+  }
+  await page.evaluate(
+    ({ endA: endA2, endB: endB2 }) => {
+      const canvas = window.__sootsimFindInteractiveCanvas?.() ?? document.querySelector("canvas");
+      if (!canvas) return;
+      canvas.dispatchEvent(
+        new PointerEvent("pointerup", {
+          bubbles: true,
+          cancelable: true,
+          clientX: endA2.x,
+          clientY: endA2.y,
+          isPrimary: true,
+          pointerId: 1001,
+          pointerType: "touch"
+        })
+      );
+      canvas.dispatchEvent(
+        new PointerEvent("pointerup", {
+          bubbles: true,
+          cancelable: true,
+          clientX: endB2.x,
+          clientY: endB2.y,
+          isPrimary: false,
+          pointerId: 1002,
+          pointerType: "touch"
+        })
+      );
+    },
+    { endA, endB }
+  );
+  await waitForWorkletCallbackDrain(page, beforeWorkletStats);
+  await page.waitForTimeout(250);
+}
+
+// detox/expectations.ts
+var DEFAULT_VISIBILITY_THRESHOLD = 0.75;
+async function scrollMatcherElement(page, findNode, matcher, pixels, direction) {
+  const node = await findNode(matcher);
+  if (!node) {
+    throw new Error(`scroll container not found: ${JSON.stringify(matcher)}`);
+  }
+  await dragScrollNode(page, node, pixels, direction);
+}
+function isNodeVisibleInViewport(node, viewport) {
+  if (!node || node.layout.width <= 0 || node.layout.height <= 0) {
+    return false;
+  }
+  const frame = node.visibleFrame ?? {
+    x: node.absolutePosition?.x ?? node.layout?.x ?? 0,
+    y: node.absolutePosition?.y ?? node.layout?.y ?? 0,
+    width: node.layout.width,
+    height: node.layout.height
+  };
+  const right = frame.x + frame.width;
+  const bottom = frame.y + frame.height;
+  const visibleWidth = Math.max(0, Math.min(right, viewport.width) - Math.max(frame.x, 0));
+  const visibleHeight = Math.max(
+    0,
+    Math.min(bottom, viewport.height) - Math.max(frame.y, 0)
+  );
+  const visibleArea = visibleWidth * visibleHeight;
+  const totalArea = node.layout.width * node.layout.height;
+  return totalArea > 0 && visibleArea / totalArea >= DEFAULT_VISIBILITY_THRESHOLD;
+}
+async function isNodeVisible(page, node) {
+  if (!node || node.layout.width <= 0 || node.layout.height <= 0) {
+    return false;
+  }
+  return isNodeVisibleInViewport(node, await readSootsimInteractiveViewport(page));
+}
+function describeNodeVisibility(node, viewport) {
+  if (!node) return "not found";
+  const absX = node.absolutePosition?.x ?? node.layout?.x ?? 0;
+  const absY = node.absolutePosition?.y ?? node.layout?.y ?? 0;
+  return JSON.stringify({
+    layout: node.layout,
+    absolutePosition: node.absolutePosition ?? null,
+    frame: {
+      x: absX,
+      y: absY,
+      right: absX + (node.layout?.width ?? 0),
+      bottom: absY + (node.layout?.height ?? 0)
+    },
+    visibleFrame: node.visibleFrame ?? null,
+    viewport: viewport ?? null,
+    style: node.style ?? null
+  });
+}
+function createExpect(findNode, getPage2) {
+  return function sootExpect2(el) {
+    return new SootExpectation(el._matcher, findNode, getPage2, false);
+  };
+}
+var SootExpectation = class _SootExpectation {
+  matcher;
+  findNode;
+  getPage;
+  negated;
+  constructor(matcher, findNode, getPage2, negated) {
+    this.matcher = matcher;
+    this.findNode = findNode;
+    this.getPage = getPage2;
+    this.negated = negated;
+  }
+  get not() {
+    return new _SootExpectation(this.matcher, this.findNode, this.getPage, !this.negated);
+  }
+  async toExist() {
+    const node = await this.findNode(this.matcher);
+    const exists = node !== null && node !== void 0;
+    if (this.negated) {
+      if (exists) {
+        throw new Error(
+          `expected element NOT to exist but it does: ${JSON.stringify(this.matcher)}`
+        );
+      }
+    } else {
+      if (!exists) {
+        throw new Error(
+          `expected element to exist but it was not found: ${JSON.stringify(this.matcher)}`
+        );
+      }
+    }
+  }
+  async toBeVisible() {
+    const node = await this.findNode(this.matcher);
+    const page = this.getPage();
+    const viewport = node ? await readSootsimInteractiveViewport(page) : void 0;
+    const visible = viewport ? isNodeVisibleInViewport(node, viewport) : false;
+    if (this.negated) {
+      if (visible) {
+        throw new Error(
+          `expected element NOT to be visible: ${JSON.stringify(this.matcher)}`
+        );
+      }
+    } else {
+      if (!visible) {
+        throw new Error(
+          `expected element to be visible but it is ${describeNodeVisibility(node, viewport)}: ${JSON.stringify(this.matcher)}`
+        );
+      }
+    }
+  }
+  async toBeNotVisible() {
+    const node = await this.findNode(this.matcher);
+    const visible = await isNodeVisible(this.getPage(), node);
+    if (visible) {
+      throw new Error(
+        `expected element NOT to be visible: ${JSON.stringify(this.matcher)}`
+      );
+    }
+  }
+  async toHaveText(expectedText) {
+    const node = await this.findNode(this.matcher);
+    if (!node) {
+      throw new Error(`element not found for toHaveText: ${JSON.stringify(this.matcher)}`);
+    }
+    const actualText = node.text || "";
+    const matches = actualText === expectedText || actualText.includes(expectedText);
+    if (this.negated) {
+      if (matches) {
+        throw new Error(
+          `expected text NOT to be "${expectedText}" but got "${actualText}": ${JSON.stringify(this.matcher)}`
+        );
+      }
+    } else {
+      if (!matches) {
+        throw new Error(
+          `expected text "${expectedText}" but got "${actualText}": ${JSON.stringify(this.matcher)}`
+        );
+      }
+    }
+  }
+  async toHaveId(expectedId) {
+    const node = await this.findNode(this.matcher);
+    if (!node) {
+      throw new Error(`element not found for toHaveId: ${JSON.stringify(this.matcher)}`);
+    }
+    const hasId = node.testID === expectedId || node.id === expectedId;
+    if (this.negated) {
+      if (hasId) throw new Error(`expected element NOT to have id "${expectedId}"`);
+    } else {
+      if (!hasId)
+        throw new Error(
+          `expected element to have id "${expectedId}" but got "${node.testID || node.id}"`
+        );
+    }
+  }
+  async toHaveLabel(expectedLabel) {
+    const node = await this.findNode(this.matcher);
+    if (!node) {
+      throw new Error(
+        `element not found for toHaveLabel: ${JSON.stringify(this.matcher)}`
+      );
+    }
+    const actual = node.accessibilityLabel || node.text || "";
+    const matches = actual === expectedLabel;
+    if (this.negated) {
+      if (matches)
+        throw new Error(`expected label NOT to be "${expectedLabel}" but it was`);
+    } else {
+      if (!matches)
+        throw new Error(
+          `expected label "${expectedLabel}" but got "${actual}": ${JSON.stringify(this.matcher)}`
+        );
+    }
+  }
+  async toHaveAccessibilityRole(expectedRole) {
+    const node = await this.findNode(this.matcher);
+    if (!node) {
+      throw new Error(
+        `element not found for toHaveAccessibilityRole: ${JSON.stringify(this.matcher)}`
+      );
+    }
+    const actual = node.accessibilityRole || "";
+    const matches = actual === expectedRole;
+    if (this.negated) {
+      if (matches) throw new Error(`expected role NOT to be "${expectedRole}" but it was`);
+    } else {
+      if (!matches)
+        throw new Error(
+          `expected role "${expectedRole}" but got "${actual}": ${JSON.stringify(this.matcher)}`
+        );
+    }
+  }
+  async toBeEnabled() {
+    const node = await this.findNode(this.matcher);
+    if (!node) {
+      throw new Error(
+        `element not found for toBeEnabled: ${JSON.stringify(this.matcher)}`
+      );
+    }
+    const disabled = node.accessibilityState?.disabled ?? false;
+    if (this.negated) {
+      if (!disabled) throw new Error(`expected element to be disabled but it is enabled`);
+    } else {
+      if (disabled) throw new Error(`expected element to be enabled but it is disabled`);
+    }
+  }
+  async toBeFocused() {
+    await this.toExist();
+  }
+  async toHaveValue(value) {
+    const node = await this.findNode(this.matcher);
+    if (!node) {
+      throw new Error(
+        `element not found for toHaveValue: ${JSON.stringify(this.matcher)}`
+      );
+    }
+    const actual = node.text || "";
+    if (this.negated) {
+      if (actual.includes(value)) {
+        throw new Error(
+          `expected element NOT to have value "${value}" but got "${actual}"`
+        );
+      }
+    } else {
+      if (!actual.includes(value)) {
+        throw new Error(`expected element to have value "${value}" but got "${actual}"`);
+      }
+    }
+  }
+  async toHaveSliderPosition(normalizedPosition, tolerance) {
+    await this.toExist();
+  }
+  async toHaveToggleValue(value) {
+    await this.toExist();
+  }
+};
+function createWaitFor(findNode, getPage2) {
+  return function sootWaitFor2(el) {
+    return new SootWaitForChain(el._matcher, findNode, getPage2);
+  };
+}
+var SootWaitForChain = class {
+  matcher;
+  findNode;
+  getPage;
+  assertionFn = null;
+  _negated = false;
+  constructor(matcher, findNode, getPage2) {
+    this.matcher = matcher;
+    this.findNode = findNode;
+    this.getPage = getPage2;
+  }
+  get not() {
+    this._negated = true;
+    return this;
+  }
+  toExist() {
+    this.assertionFn = async () => {
+      const node = await this.findNode(this.matcher);
+      const exists = node !== null && node !== void 0;
+      if (this._negated ? exists : !exists) {
+        throw new Error(`waitFor toExist failed: ${JSON.stringify(this.matcher)}`);
+      }
+    };
+    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+  toBeVisible() {
+    this.assertionFn = async () => {
+      const node = await this.findNode(this.matcher);
+      const page = this.getPage();
+      const viewport = node ? await readSootsimInteractiveViewport(page) : void 0;
+      const visible = viewport ? isNodeVisibleInViewport(node, viewport) : false;
+      if (this._negated ? visible : !visible) {
+        throw new Error(
+          `waitFor toBeVisible failed (${describeNodeVisibility(node, viewport)}): ${JSON.stringify(this.matcher)}`
+        );
+      }
+    };
+    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+  toBeNotVisible() {
+    this.assertionFn = async () => {
+      const node = await this.findNode(this.matcher);
+      const visible = await isNodeVisible(this.getPage(), node);
+      if (visible) {
+        throw new Error(`waitFor toBeNotVisible failed: ${JSON.stringify(this.matcher)}`);
+      }
+    };
+    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+  toHaveText(expectedText) {
+    this.assertionFn = async () => {
+      const node = await this.findNode(this.matcher);
+      if (!node)
+        throw new Error(
+          `waitFor toHaveText: element not found: ${JSON.stringify(this.matcher)}`
+        );
+      const actual = node.text || "";
+      const matches = actual === expectedText || actual.includes(expectedText);
+      if (this._negated ? matches : !matches) {
+        throw new Error(
+          `waitFor toHaveText: expected "${expectedText}" but got "${actual}" ${JSON.stringify(this.matcher)}`
+        );
+      }
+    };
+    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+  toHaveValue(value) {
+    this.assertionFn = async () => {
+      const node = await this.findNode(this.matcher);
+      if (!node) throw new Error(`waitFor toHaveValue: element not found`);
+      const actual = node.text || "";
+      if (!actual.includes(value)) {
+        throw new Error(`waitFor toHaveValue: expected "${value}" in "${actual}"`);
+      }
+    };
+    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+};
+var SootWaitForAction = class {
+  assertionFn;
+  findNode;
+  getPage;
+  constructor(assertionFn, findNode, getPage2) {
+    this.assertionFn = assertionFn;
+    this.findNode = findNode;
+    this.getPage = getPage2;
+  }
+  async withTimeout(ms) {
+    const start = Date.now();
+    const pollInterval = 100;
+    let lastError = null;
+    while (Date.now() - start < ms) {
+      try {
+        await this.assertionFn();
+        return;
+      } catch (e) {
+        lastError = e;
+        await new Promise((r) => setTimeout(r, pollInterval));
+      }
+    }
+    throw lastError || new Error(`waitFor timed out after ${ms}ms`);
+  }
+  // if no withTimeout is called, just run the assertion once
+  async then(resolve, reject) {
+    try {
+      await this.withTimeout(5e3);
+      resolve(void 0);
+    } catch (e) {
+      reject(e);
+    }
+  }
+  whileElement(matcher) {
+    return new SootWaitForScrollAction(
+      this.assertionFn,
+      this.findNode,
+      this.getPage,
+      matcher
+    );
+  }
+};
+var SootWaitForScrollAction = class {
+  assertionFn;
+  findNode;
+  getPage;
+  matcher;
+  constructor(assertionFn, findNode, getPage2, matcher) {
+    this.assertionFn = assertionFn;
+    this.findNode = findNode;
+    this.getPage = getPage2;
+    this.matcher = matcher;
+  }
+  async scroll(pixels, direction, _startPositionX, _startPositionY) {
+    const page = this.getPage();
+    const start = Date.now();
+    const timeoutMs = 5e3;
+    let lastError = null;
+    while (Date.now() - start < timeoutMs) {
+      try {
+        await this.assertionFn();
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+      await scrollMatcherElement(page, this.findNode, this.matcher, pixels, direction);
+    }
+    throw lastError || new Error(
+      `waitFor whileElement(...).scroll() timed out: ${JSON.stringify(this.matcher)}`
+    );
+  }
+};
+
+// detox/matchers.ts
+var by = {
+  id(testID) {
+    return { type: "id", value: testID };
+  },
+  text(text) {
+    return { type: "text", value: text };
+  },
+  label(accessibilityLabel) {
+    return { type: "label", value: accessibilityLabel };
+  },
+  type(nativeType) {
+    return { type: "type", value: nativeType };
+  },
+  role(accessibilityRole) {
+    return { type: "role", value: accessibilityRole };
+  }
+};
+
+// detox/index.ts
+var BASE_URL = process.env.SOOTSIM_URL || "http://localhost:5173";
+var SCREENSHOT_DIR = process.env.SOOTSIM_SCREENSHOT_DIR || path.join(process.cwd(), "test", "detox-driver", "screenshots");
+var DETOX_PLATFORM = process.env.SOOTSIM_PLATFORM === "android" ? "android" : "ios";
+var _browser = null;
+var _context = null;
+var _page = null;
+var _synchronizationEnabled = false;
+var pageDiagnostics = /* @__PURE__ */ new WeakMap();
+var STATUS_BAR_OVERRIDE_EVENT = "sootsim:statusBarOverride";
+function getPage() {
+  if (!_page)
+    throw new Error("sootsim driver not initialized -- call device.launchApp() first");
+  return _page;
+}
+function recordPageDiagnostic(page, message) {
+  const entries = pageDiagnostics.get(page);
+  if (!entries) return;
+  entries.push(message);
+  if (entries.length > 40) entries.shift();
+}
+function attachPageDiagnostics(page) {
+  if (pageDiagnostics.has(page)) return;
+  pageDiagnostics.set(page, []);
+  page.on("console", (message) => {
+    recordPageDiagnostic(page, `[console:${message.type()}] ${message.text()}`);
+  });
+  page.on("pageerror", (error) => {
+    recordPageDiagnostic(page, `[pageerror] ${error.message}`);
+  });
+  page.on("requestfailed", (request) => {
+    const failure = request.failure();
+    recordPageDiagnostic(
+      page,
+      `[requestfailed] ${request.method()} ${request.url()} ${failure?.errorText ?? ""}`
+    );
+  });
+}
+async function describeSootsimBridgeFailure(page, cause) {
+  let pageState = null;
+  try {
+    pageState = await page.evaluate(() => ({
+      bodyText: document.body?.innerText?.slice(0, 500) ?? "",
+      globals: Object.keys(window).filter((key) => key.startsWith("__sootsim") || key === "SootSim").sort(),
+      readyState: document.readyState,
+      title: document.title,
+      url: window.location.href
+    }));
+  } catch (error) {
+    pageState = {
+      evaluateError: error instanceof Error ? error.message : String(error)
+    };
+  }
+  return new Error(
+    [
+      `timed out waiting for sootsim test bridge`,
+      `cause: ${cause instanceof Error ? cause.message : String(cause)}`,
+      `page: ${JSON.stringify(pageState)}`,
+      `recent page diagnostics:
+${(pageDiagnostics.get(page) ?? []).join("\n") || "(none)"}`
+    ].join("\n")
+  );
+}
+async function waitForSootsimTree(page, timeout = 3e4) {
+  try {
+    await page.waitForFunction(() => !!window.__sootsimTest?.waitForTree, {
+      timeout
+    });
+    await page.evaluate(async (timeoutMs) => {
+      await Promise.race([
+        window.__sootsimTest.waitForTree(),
+        new Promise((_, reject) => {
+          setTimeout(
+            () => reject(new Error(`sootsim waitForTree timed out after ${timeoutMs}ms`)),
+            timeoutMs
+          );
+        })
+      ]);
+    }, timeout);
+  } catch (error) {
+    throw await describeSootsimBridgeFailure(page, error);
+  }
+}
+async function closeContext() {
+  const context = _context;
+  _context = null;
+  _page = null;
+  _synchronizationEnabled = false;
+  if (context) await context.close();
+}
+async function closeBrowser() {
+  if (!_browser) return;
+  const browser = _browser;
+  _browser = null;
+  await closeContext();
+  await browser.close();
+}
+async function waitForSootsimIdle(page, maxMs = 3e3) {
+  const result = await page.evaluate(
+    async ({ maxMs: maxMs2 }) => {
+      let transitionError = null;
+      try {
+        const waitForScreenTransitions = window.__sootsimTest?.waitForScreenTransitions;
+        if (typeof waitForScreenTransitions === "function") {
+          const transitionResult = await waitForScreenTransitions({
+            timeoutMs: Math.min(maxMs2, 1800),
+            settleMs: 48,
+            startWindowMs: 600
+          });
+          if (transitionResult?.started === true && transitionResult.settled === true && transitionResult.timedOut !== true) {
+            return { settled: true, elapsed: transitionResult.waitedMs ?? 0 };
+          }
+          if (transitionResult?.timedOut) {
+            return {
+              settled: false,
+              elapsed: transitionResult.waitedMs,
+              reason: "screen transition"
+            };
+          }
+        }
+      } catch (error) {
+        transitionError = error instanceof Error ? error.message : String(error);
+      }
+      const start = Date.now();
+      const deadline = start + maxMs2;
+      const pollMs = 50;
+      const requiredStablePolls = 3;
+      const layoutTolerance = 1;
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      const isLayoutStable = (a, b) => {
+        if (!a || a.length !== b.length) return false;
+        for (let i = 0; i < b.length; i++) {
+          if (Math.abs(a[i] - b[i]) > layoutTolerance) return false;
+        }
+        return true;
+      };
+      const readSnapshot = async () => {
+        const root = window.__sootsimRoot;
+        const layout = [];
+        if (root) {
+          const walk = (node) => {
+            if (node.layout && node.layout.width > 0) {
+              layout.push(
+                Math.round(node.layout.x),
+                Math.round(node.layout.y),
+                Math.round(node.layout.width),
+                Math.round(node.layout.height)
+              );
+            }
+            for (const child of node.children || []) walk(child);
+          };
+          walk(root);
+        }
+        return layout;
+      };
+      let stableLayout = null;
+      let stable = 0;
+      while (Date.now() < deadline) {
+        const layout = await readSnapshot();
+        if (isLayoutStable(stableLayout, layout)) {
+          stable++;
+          if (stable >= requiredStablePolls) {
+            return { settled: true, elapsed: Date.now() - start };
+          }
+        } else {
+          stableLayout = layout;
+          stable = 0;
+        }
+        await sleep(pollMs);
+      }
+      return {
+        settled: false,
+        elapsed: Date.now() - start,
+        reason: transitionError ? `layout fallback after screen transition wait failed: ${transitionError}` : "layout fallback"
+      };
+    },
+    { maxMs }
+  );
+  if (!result?.settled) {
+    throw new Error(
+      `sootsim synchronization timed out after ${result?.elapsed ?? maxMs}ms${result?.reason ? ` (${result.reason})` : ""}`
+    );
+  }
+}
+async function findNodeByMatcher(matcher) {
+  const page = getPage();
+  if (matcher.type === "id") {
+    return page.evaluate(
+      (id) => window.__sootsimTest.findByTestId(id),
+      matcher.value
+    );
+  } else if (matcher.type === "text") {
+    return page.evaluate(
+      (text) => window.__sootsimTest.findByText(text),
+      matcher.value
+    );
+  } else if (matcher.type === "label") {
+    return page.evaluate(
+      (label) => window.__sootsimTest.findByLabel(label),
+      matcher.value
+    );
+  } else if (matcher.type === "role") {
+    return page.evaluate(
+      (role) => window.__sootsimTest.findByRole(role),
+      matcher.value
+    );
+  } else if (matcher.type === "type") {
+    return page.evaluate(async (type) => {
+      const results = await window.__sootsimTest.queryAll({ type });
+      return results[0] || null;
+    }, matcher.value);
+  }
+  return null;
+}
+function getNodeCenter(nodeInfo) {
+  return {
+    x: nodeInfo.absolutePosition.x + nodeInfo.layout.width / 2,
+    y: nodeInfo.absolutePosition.y + nodeInfo.layout.height / 2
+  };
+}
+async function getDefaultTapPoint(page, nodeInfo) {
+  const center = getNodeCenter(nodeInfo);
+  const viewport = await readSootsimInteractiveViewport(page);
+  const frame = nodeInfo.visibleFrame ?? {
+    x: nodeInfo.absolutePosition?.x ?? nodeInfo.layout?.x ?? 0,
+    y: nodeInfo.absolutePosition?.y ?? nodeInfo.layout?.y ?? 0,
+    width: nodeInfo.layout?.width ?? 0,
+    height: nodeInfo.layout?.height ?? 0
+  };
+  const left = Math.max(0, frame.x);
+  const top = Math.max(0, frame.y);
+  const right = Math.min(viewport.width, frame.x + frame.width);
+  const bottom = Math.min(viewport.height, frame.y + frame.height);
+  if (right <= left || bottom <= top) {
+    return center;
+  }
+  return {
+    x: left + (right - left) / 2,
+    y: top + (bottom - top) / 2
+  };
+}
+async function isFocusedTextInputNode(page, nodeInfo) {
+  const focused = await page.evaluate(
+    () => window.__sootsimTest.getFocusedNode?.() ?? null
+  );
+  return !!focused && typeof focused === "object" && focused.nodeId === nodeInfo?.nodeId;
+}
+async function focusElementForTextEntry(el) {
+  const page = getPage();
+  const node = await findNodeByMatcher(el._matcher);
+  if (!node) {
+    throw new Error(`element not found for text entry: ${JSON.stringify(el._matcher)}`);
+  }
+  if (await isFocusedTextInputNode(page, node)) return;
+  await el.tap();
+  await page.waitForTimeout(100);
+}
+function ensureScreenshotDir() {
+  if (!fs.existsSync(SCREENSHOT_DIR)) {
+    fs.mkdirSync(SCREENSHOT_DIR, { recursive: true });
+  }
+}
+function decodePngDataUrl(dataUrl) {
+  const match = /^data:image\/png;base64,(.+)$/.exec(dataUrl);
+  if (!match) {
+    throw new Error("sootsim screenshot bridge returned a non-png payload");
+  }
+  return Buffer.from(match[1], "base64");
+}
+async function captureSootsimPngFast(opts) {
+  const page = getPage();
+  const dataUrl = await page.evaluate(
+    async (captureOpts) => {
+      const screenshot = window.SootSim?.bridges?.screenshot;
+      if (typeof screenshot !== "function") {
+        throw new Error("sootsim screenshot bridge is not installed");
+      }
+      return screenshot(captureOpts);
+    },
+    { crop: opts?.crop }
+  );
+  if (!dataUrl) {
+    throw new Error("sootsim screenshot bridge returned an empty image");
+  }
+  return decodePngDataUrl(dataUrl);
+}
+async function captureSootsimPng(opts) {
+  const page = getPage();
+  const result = await page.evaluate(
+    async (captureOpts) => {
+      const screenshot = window.SootSim?.bridges?.screenshot;
+      if (typeof screenshot !== "function") {
+        throw new Error("sootsim screenshot bridge is not installed");
+      }
+      const gapMs = 100;
+      const maxWaitMs = 8e3;
+      const minAttempts = 3;
+      const t0 = Date.now();
+      let prev = await screenshot(captureOpts);
+      let attempts = 1;
+      while (attempts < minAttempts || Date.now() - t0 < maxWaitMs) {
+        await new Promise((r) => setTimeout(r, gapMs));
+        const next = await screenshot(captureOpts);
+        attempts++;
+        if (next === prev) {
+          return {
+            dataUrl: next,
+            stable: true,
+            attempts,
+            elapsedMs: Date.now() - t0
+          };
+        }
+        prev = next;
+      }
+      return { dataUrl: prev, stable: false, attempts, elapsedMs: Date.now() - t0 };
+    },
+    {
+      crop: opts?.crop
+    }
+  );
+  if (!result.dataUrl) {
+    throw new Error("sootsim screenshot bridge returned an empty image");
+  }
+  if (!result.stable) {
+    console.warn(
+      `[sootsim-detox] screenshot did not stabilize after ${result.elapsedMs}ms (${result.attempts} captures); using last frame`
+    );
+  }
+  return decodePngDataUrl(result.dataUrl);
+}
+async function writeSootsimScreenshot(name, opts) {
+  ensureScreenshotDir();
+  const screenshotPath = path.join(SCREENSHOT_DIR, `${name}.png`);
+  fs.writeFileSync(screenshotPath, await captureSootsimPng(opts));
+  return screenshotPath;
+}
+async function dispatchStatusBarOverride(config) {
+  const page = getPage();
+  const time = typeof config.time === "string" && config.time.length > 0 ? config.time : null;
+  await page.evaluate(
+    ({ eventType, time: time2 }) => {
+      window.dispatchEvent(
+        new CustomEvent(eventType, {
+          detail: { time: time2 }
+        })
+      );
+    },
+    { eventType: STATUS_BAR_OVERRIDE_EVENT, time }
+  );
+  await page.waitForTimeout(50);
+}
+async function dispatchSootsimEventInPage(type, detail) {
+  const page = getPage();
+  await page.evaluate(
+    ({ detail: detail2, type: type2 }) => {
+      window.dispatchEvent(new CustomEvent(type2, { detail: detail2 }));
+    },
+    { detail, type }
+  );
+}
+function createSootElement(matcher) {
+  const el = {
+    _matcher: matcher,
+    async tap(point) {
+      const page = getPage();
+      const node = await findNodeByMatcher(matcher);
+      if (!node) throw new Error(`element not found for tap: ${JSON.stringify(matcher)}`);
+      const defaultPoint = point ? null : await getDefaultTapPoint(page, node);
+      const targetSootX = typeof point?.x === "number" ? node.absolutePosition.x + point.x : defaultPoint?.x ?? node.absolutePosition.x + node.layout.width / 2;
+      const targetSootY = typeof point?.y === "number" ? node.absolutePosition.y + point.y : defaultPoint?.y ?? node.absolutePosition.y + node.layout.height / 2;
+      await page.evaluate(
+        async ({ x, y }) => {
+          const interactTap = window.SootSim?.bridges?.interact?.tap;
+          if (typeof interactTap === "function") {
+            const result = await interactTap(x, y);
+            if (result && (typeof result !== "object" || result.hit !== false)) return;
+          }
+          const tap = window.__sootsimTest?.tap;
+          if (typeof tap !== "function") {
+            throw new Error("sootsim tap bridge is not installed");
+          }
+          await tap(x, y);
+        },
+        { x: targetSootX, y: targetSootY }
+      );
+      await page.waitForTimeout(50);
+      if (_synchronizationEnabled) {
+        await waitForSootsimIdle(page);
+      }
+    },
+    async multiTap(times) {
+      const page = getPage();
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(`element not found for multiTap: ${JSON.stringify(matcher)}`);
+      const center = getNodeCenter(node);
+      const pageCoords = await sootsimToPage(page, center.x, center.y);
+      for (let i = 0; i < times; i++) {
+        await page.mouse.move(pageCoords.x, pageCoords.y);
+        await page.mouse.down();
+        await page.waitForTimeout(50);
+        await page.mouse.up();
+        if (i < times - 1) {
+          await page.waitForTimeout(80);
+        }
+      }
+      await page.waitForTimeout(80);
+    },
+    async longPress(duration = 1e3) {
+      const page = getPage();
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(`element not found for longPress: ${JSON.stringify(matcher)}`);
+      const center = getNodeCenter(node);
+      const pageCoords = await sootsimToPage(page, center.x, center.y);
+      await page.mouse.move(pageCoords.x, pageCoords.y);
+      await page.mouse.down();
+      await page.waitForTimeout(duration);
+      await page.mouse.up();
+      await page.waitForTimeout(50);
+    },
+    async longPressAndDrag(duration, normalizedStartX, normalizedStartY, targetElement, normalizedEndX, normalizedEndY, speed = "fast", holdDuration = 0) {
+      const page = getPage();
+      const srcNode = await findNodeByMatcher(matcher);
+      if (!srcNode)
+        throw new Error(`source element not found: ${JSON.stringify(matcher)}`);
+      const tgtNode = await findNodeByMatcher(targetElement._matcher);
+      if (!tgtNode)
+        throw new Error(
+          `target element not found: ${JSON.stringify(targetElement._matcher)}`
+        );
+      const startSootX = srcNode.absolutePosition.x + srcNode.layout.width * normalizedStartX;
+      const startSootY = srcNode.absolutePosition.y + srcNode.layout.height * normalizedStartY;
+      const endSootX = tgtNode.absolutePosition.x + tgtNode.layout.width * normalizedEndX;
+      const endSootY = tgtNode.absolutePosition.y + tgtNode.layout.height * normalizedEndY;
+      const startPage = await sootsimToPage(page, startSootX, startSootY);
+      const endPage = await sootsimToPage(page, endSootX, endSootY);
+      const steps = speed === "slow" ? 20 : 10;
+      await page.mouse.move(startPage.x, startPage.y);
+      await page.mouse.down();
+      await page.waitForTimeout(Math.max(duration, holdDuration));
+      const dx = (endPage.x - startPage.x) / steps;
+      const dy = (endPage.y - startPage.y) / steps;
+      for (let i = 1; i <= steps; i++) {
+        await page.mouse.move(startPage.x + dx * i, startPage.y + dy * i);
+        await page.waitForTimeout(speed === "slow" ? 30 : 10);
+      }
+      await page.mouse.up();
+      await page.waitForTimeout(50);
+    },
+    async typeText(text) {
+      const page = getPage();
+      await focusElementForTextEntry(el);
+      await page.keyboard.type(text);
+    },
+    async replaceText(text) {
+      const page = getPage();
+      await focusElementForTextEntry(el);
+      const node = await findNodeByMatcher(matcher);
+      const value = typeof node?.text === "string" ? node.text : "";
+      for (let i = 0; i < value.length; i++) {
+        await page.keyboard.press("Backspace");
+      }
+      await page.keyboard.type(text);
+    },
+    async clearText() {
+      const page = getPage();
+      await focusElementForTextEntry(el);
+      const node = await findNodeByMatcher(matcher);
+      const value = typeof node?.text === "string" ? node.text : "";
+      for (let i = 0; i < value.length; i++) {
+        await page.keyboard.press("Backspace");
+      }
+    },
+    async scroll(pixels, direction) {
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(`element not found for scroll: ${JSON.stringify(matcher)}`);
+      const page = getPage();
+      await dragScrollNode(page, node, pixels, direction);
+    },
+    async scrollTo(edge) {
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(`element not found for scrollTo: ${JSON.stringify(matcher)}`);
+      const targetId = typeof node.testID === "string" && node.testID ? node.testID : typeof node.id === "string" && node.id ? node.id : null;
+      if (!targetId) {
+        throw new Error(
+          `scrollTo requires an id-backed scroll view: ${JSON.stringify(matcher)}`
+        );
+      }
+      const hitX = node.absolutePosition.x + node.layout.width / 2;
+      const hitY = node.absolutePosition.y + node.layout.height / 2;
+      const page = getPage();
+      const result = await page.evaluate(
+        async ({ edge: edge2, hitX: hitX2, hitY: hitY2, targetId: targetId2 }) => {
+          const bridge = window.__sootsimTest;
+          if (!bridge?.getScrollStateAt || !bridge.scrollTo) {
+            return { ok: false, reason: "scroll bridge unavailable" };
+          }
+          const state = await bridge.getScrollStateAt(hitX2, hitY2);
+          if (!state) return { ok: false, reason: "scroll state not found" };
+          const maxOffset = state.maxOffset && typeof state.maxOffset === "object" ? state.maxOffset : null;
+          const offset = state.offset && typeof state.offset === "object" ? state.offset : null;
+          const maxX = typeof state.maxOffsetX === "number" ? state.maxOffsetX : maxOffset?.x ?? 0;
+          const maxY = typeof state.maxOffsetY === "number" ? state.maxOffsetY : maxOffset?.y ?? 0;
+          const currentX = typeof state.offsetX === "number" ? state.offsetX : offset?.x ?? 0;
+          const currentY = typeof state.offsetY === "number" ? state.offsetY : offset?.y ?? 0;
+          const x = edge2 === "left" ? 0 : edge2 === "right" ? maxX : currentX;
+          const y = edge2 === "top" ? 0 : edge2 === "bottom" ? maxY : currentY;
+          return bridge.scrollTo(targetId2, x, y, false);
+        },
+        { edge, hitX, hitY, targetId }
+      );
+      if (!result?.ok) {
+        throw new Error(
+          `scrollTo(${edge}) failed for ${targetId}: ${result?.reason ?? "unknown error"}`
+        );
+      }
+      await page.evaluate(
+        () => new Promise((resolve) => {
+          requestAnimationFrame(() => resolve());
+        })
+      );
+      if (_synchronizationEnabled) {
+        await waitForSootsimIdle(page);
+      }
+    },
+    async swipe(direction, speed = "fast", percentage = 0.75) {
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(`element not found for swipe: ${JSON.stringify(matcher)}`);
+      const page = getPage();
+      const { absolutePosition, layout } = node;
+      const startSootX = absolutePosition.x + layout.width * 0.5;
+      const startSootY = absolutePosition.y + layout.height * 0.5;
+      let endSootX = startSootX;
+      let endSootY = startSootY;
+      const dist = direction === "up" || direction === "down" ? layout.height * percentage : layout.width * percentage;
+      switch (direction) {
+        case "up":
+          endSootY -= dist;
+          break;
+        case "down":
+          endSootY += dist;
+          break;
+        case "left":
+          endSootX -= dist;
+          break;
+        case "right":
+          endSootX += dist;
+          break;
+      }
+      const steps = speed === "slow" ? 20 : speed === "fast" ? 8 : 12;
+      const stepDelay = speed === "slow" ? 25 : speed === "fast" ? 5 : 15;
+      await page.evaluate(
+        async ({ fromX, fromY, toX, toY, steps: steps2, stepMs }) => {
+          const drag = window.__sootsimTest?.drag;
+          if (typeof drag !== "function") {
+            throw new Error("sootsim drag bridge is not installed");
+          }
+          await drag(fromX, fromY, toX, toY, steps2, stepMs);
+        },
+        {
+          fromX: startSootX,
+          fromY: startSootY,
+          toX: endSootX,
+          toY: endSootY,
+          steps,
+          stepMs: stepDelay
+        }
+      );
+      await page.waitForTimeout(100);
+    },
+    async pinch(scale, speed = "fast", angle = 0) {
+      const page = getPage();
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(`element not found for pinch: ${JSON.stringify(matcher)}`);
+      await waitForSootsimGestureHandler(page, node.nodeId, "PinchGestureHandler");
+      const center = getNodeCenter(node);
+      const centerPage = await sootsimToPage(page, center.x, center.y);
+      const startSpread = 60;
+      const endSpread = startSpread * Math.max(scale, 0.05);
+      const cos = Math.cos(angle);
+      const sin = Math.sin(angle);
+      const offset = (d) => ({ dx: d * cos, dy: d * sin });
+      const a0 = offset(-startSpread);
+      const b0 = offset(startSpread);
+      const a1 = offset(-endSpread);
+      const b1 = offset(endSpread);
+      await dispatchTwoFingerGesture(
+        page,
+        { x: centerPage.x + a0.dx, y: centerPage.y + a0.dy },
+        { x: centerPage.x + b0.dx, y: centerPage.y + b0.dy },
+        { x: centerPage.x + a1.dx, y: centerPage.y + a1.dy },
+        { x: centerPage.x + b1.dx, y: centerPage.y + b1.dy },
+        { steps: speed === "fast" ? 4 : 12, stepDelayMs: speed === "fast" ? 18 : 24 }
+      );
+    },
+    async rotate(radians, speed = "fast") {
+      const page = getPage();
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(`element not found for rotate: ${JSON.stringify(matcher)}`);
+      await waitForSootsimGestureHandler(page, node.nodeId, "RotationGestureHandler");
+      const center = getNodeCenter(node);
+      const centerPage = await sootsimToPage(page, center.x, center.y);
+      const radius = 60;
+      const startA = { x: centerPage.x - radius, y: centerPage.y };
+      const startB = { x: centerPage.x + radius, y: centerPage.y };
+      const cos = Math.cos(radians);
+      const sin = Math.sin(radians);
+      const endA = {
+        x: centerPage.x - radius * cos,
+        y: centerPage.y - radius * sin
+      };
+      const endB = {
+        x: centerPage.x + radius * cos,
+        y: centerPage.y + radius * sin
+      };
+      await dispatchTwoFingerGesture(page, startA, startB, endA, endB, {
+        steps: speed === "fast" ? 10 : 20,
+        stepDelayMs: speed === "fast" ? 14 : 24
+      });
+    },
+    async takeScreenshot(name) {
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(
+          `element not found for takeScreenshot: ${JSON.stringify(matcher)}`
+        );
+      return writeSootsimScreenshot(name, {
+        crop: {
+          x: node.absolutePosition.x,
+          y: node.absolutePosition.y,
+          w: node.layout.width,
+          h: node.layout.height
+        }
+      });
+    },
+    async getAttributes() {
+      const node = await findNodeByMatcher(matcher);
+      if (!node)
+        throw new Error(`element not found for getAttributes: ${JSON.stringify(matcher)}`);
+      return {
+        text: node.text || "",
+        label: node.accessibilityLabel || node.text || "",
+        identifier: node.testID || node.id || "",
+        visible: node.layout.width > 0 && node.layout.height > 0,
+        enabled: !node.accessibilityState?.disabled,
+        ...node
+      };
+    },
+    atIndex(_index) {
+      return el;
+    }
+  };
+  return el;
+}
+function element(matcher) {
+  return createSootElement(matcher);
+}
+var device = {
+  _currentUrl: "",
+  _platform: DETOX_PLATFORM,
+  async launchApp(opts) {
+    if (!_browser) {
+      _browser = await import_playwright.chromium.launch({ headless: true });
+    }
+    if (!_page || opts?.newInstance || opts?.delete || opts?.recordVideoDir) {
+      await closeContext();
+      const contextOpts = {
+        hasTouch: true,
+        viewport: { width: 500, height: 900 }
+      };
+      if (opts?.recordVideoDir) {
+        fs.mkdirSync(opts.recordVideoDir, { recursive: true });
+        contextOpts.recordVideo = {
+          dir: opts.recordVideoDir,
+          size: { width: 500, height: 900 }
+        };
+      }
+      _context = await _browser.newContext(contextOpts);
+      _page = await _context.newPage();
+      attachPageDiagnostics(_page);
+    }
+    const url = opts?.url || BASE_URL;
+    device._currentUrl = url;
+    await _page.goto(url, { waitUntil: "load", timeout: 3e4 });
+    await waitForSootsimTree(_page, 3e4);
+    device._lastReadyAtMs = Date.now();
+    await _page.waitForTimeout(500);
+  },
+  _lastReadyAtMs: 0,
+  async reloadReactNative() {
+    const page = getPage();
+    await page.reload({ waitUntil: "load", timeout: 3e4 });
+    await waitForSootsimTree(page, 3e4);
+    await page.waitForTimeout(500);
+  },
+  async terminateApp() {
+    await closeBrowser();
+  },
+  async installApp() {
+  },
+  async uninstallApp() {
+  },
+  async openURL(url) {
+    const page = getPage();
+    await page.goto(url.url, { waitUntil: "load", timeout: 3e4 });
+    await waitForSootsimTree(page, 1e4);
+  },
+  async takeScreenshot(name) {
+    return writeSootsimScreenshot(name);
+  },
+  // single-shot variant for multi-stage animation captures. skips the
+  // frame-stability poll so callers can sample mid-transition.
+  async takeScreenshotFast(name) {
+    ensureScreenshotDir();
+    const screenshotPath = path.join(SCREENSHOT_DIR, `${name}.png`);
+    fs.writeFileSync(screenshotPath, await captureSootsimPngFast());
+    return screenshotPath;
+  },
+  // record the SootSim canvas via the engine's headless recorder
+  // (window.__sootsimRecorder — @sootsim/plugin-recording). this is the
+  // SAME code path `bun sootsim record video` drives, NOT the rail-button
+  // path (SootSim.bridges.startRecording wires the dialog state machine
+  // and never stashes the resulting blob into __sootsimRecorder.lastBlob,
+  // which is what getBlobBase64 streams from).
+  //
+  // unlike playwright's page-level recordVideo, the headless recorder
+  // captures ONLY the device canvas (composited shell + tenant surfaces)
+  // — no browser chrome, no menu bar, no device frame. uses the EXISTING
+  // page/context so per-test state is preserved across capture.
+  async startBridgeRecording(opts) {
+    const page = getPage();
+    const startOpts = {
+      format: "webm",
+      fps: opts?.fps ?? 60,
+      layers: opts?.layers ?? "tenant",
+      durationMs: opts?.durationMs ?? 5e3
+    };
+    const result = await page.evaluate(async (startOpts2) => {
+      const rec = window.__sootsimRecorder;
+      const start = rec?.start;
+      if (typeof start !== "function") {
+        return { ok: false, error: "__sootsimRecorder.start not installed" };
+      }
+      return start(startOpts2);
+    }, startOpts);
+    if (!result.ok) {
+      throw new Error(`startBridgeRecording failed: ${result.error ?? "unknown"}`);
+    }
+  },
+  // stop the headless recorder, stream the resulting blob in chunks (same
+  // protocol as `bun sootsim record`), and write the webm to outPath.
+  async stopAndSaveBridgeRecording(outPath) {
+    const page = getPage();
+    const stopResult = await page.evaluate(async () => {
+      const rec = window.__sootsimRecorder;
+      const stop = rec?.stop;
+      if (typeof stop !== "function") {
+        return { ok: false, error: "__sootsimRecorder.stop not installed" };
+      }
+      return stop();
+    });
+    if (!stopResult.ok) {
+      throw new Error(`stopBridgeRecording failed: ${stopResult.error ?? "unknown"}`);
+    }
+    if (!stopResult.size) {
+      throw new Error("stopBridgeRecording: recorder returned empty blob");
+    }
+    const chunks = [];
+    let offset = 0;
+    const CHUNK = 2 * 1024 * 1024;
+    while (true) {
+      const result = await page.evaluate(
+        ({ offset: offset2, chunk }) => {
+          const rec = window.__sootsimRecorder;
+          const get = rec?.getBlobBase64;
+          if (typeof get !== "function") return null;
+          return get({ offset: offset2, chunk });
+        },
+        { offset, chunk: CHUNK }
+      );
+      if (!result) throw new Error("SootSim recorder produced no blob");
+      chunks.push(Buffer.from(result.data, "base64"));
+      offset = result.offset;
+      if (result.done) break;
+    }
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, Buffer.concat(chunks));
+    this._lastRecordingPath = outPath;
+    return outPath;
+  },
+  _lastRecordingPath: "",
+  // set the engine's ContextMenu animation-progress override. visual-proof
+  // harnesses use this to drive each capture stage to a known animProgress
+  // (matched against the iOS oracle's curve) instead of fighting capture
+  // latency vs. sub-second spring timing. pass null to clear.
+  //
+  // dispatches a host CustomEvent that the engine forwards to the tenant
+  // worker (see shell-event-registry.ts + input-bridge.ts handleShellEvent).
+  // the worker writes globalThis.__sootsimMenuAnimOverride which the engine
+  // ContextMenu reads each rAF tick.
+  async setMenuAnimOverride(progress) {
+    await dispatchSootsimEventInPage("sootsim:menuAnimOverride", { value: progress });
+  },
+  async setBottomTabAnimOverride(value) {
+    await dispatchSootsimEventInPage("sootsim:bottomTabAnimOverride", { value });
+  },
+  // FAST multi-stage capture for sub-second animation diffs. each stage
+  // schedules a setTimeout at its requested offsetMs and at that moment
+  // SYNCHRONOUSLY snapshots the engine's `liveComposite` host-side canvas
+  // (drawImage from the worker-transferred home + overlay canvases). PNG
+  // encoding is queued after all snapshots land — encoding stalls don't
+  // contaminate the animation window.
+  //
+  // unlike `takeScreenshotStages`, this does NOT go through screenshot()
+  // (which calls forceRenderAll + composite + toDataURL serially at
+  // 300-1300ms per call and blows the spring-open timing). the worker's
+  // vsync-pumped rAF keeps the home canvas fresh; we just sample it.
+  //
+  // returns paths in stage order; actualMs reports when the snapshot
+  // actually fired (typically within a few ms of offsetMs).
+  async takeScreenshotStagesFast(namePrefix, stages) {
+    const page = getPage();
+    const frames = await page.evaluate(
+      async (input) => {
+        const sim = window;
+        const screenshot = sim.SootSim?.bridges?.screenshot;
+        const live = sim.SootSim?.bridges?.liveComposite;
+        if (typeof screenshot !== "function") {
+          throw new Error("SootSim screenshot bridge is not installed");
+        }
+        await screenshot();
+        const start = performance.now();
+        const snaps = await Promise.all(
+          input.stages.map(
+            (stage) => new Promise((resolve) => {
+              const fire = async () => {
+                const actualMs = performance.now() - start;
+                try {
+                  let dataUrl = null;
+                  if (live && typeof live.captureFresh === "function") {
+                    const { canvas } = await live.captureFresh();
+                    if (canvas) {
+                      const bmp = await createImageBitmap(canvas);
+                      const enc = document.createElement("canvas");
+                      enc.width = bmp.width;
+                      enc.height = bmp.height;
+                      const ctx = enc.getContext("2d");
+                      if (ctx) {
+                        ctx.drawImage(bmp, 0, 0);
+                        dataUrl = enc.toDataURL("image/png");
+                      }
+                      bmp.close();
+                    }
+                  }
+                  if (!dataUrl) {
+                    dataUrl = await screenshot();
+                  }
+                  resolve({
+                    label: stage.label,
+                    offsetMs: stage.offsetMs,
+                    actualMs,
+                    dataUrl
+                  });
+                } catch {
+                  resolve({
+                    label: stage.label,
+                    offsetMs: stage.offsetMs,
+                    actualMs,
+                    dataUrl: null
+                  });
+                }
+              };
+              setTimeout(
+                () => {
+                  void fire();
+                },
+                Math.max(0, stage.offsetMs)
+              );
+            })
+          )
+        );
+        const out = [];
+        for (const snap of snaps) {
+          if (!snap.dataUrl) continue;
+          out.push({
+            label: snap.label,
+            offsetMs: snap.offsetMs,
+            actualMs: snap.actualMs,
+            dataUrl: snap.dataUrl
+          });
+        }
+        return out;
+      },
+      { stages }
+    );
+    ensureScreenshotDir();
+    return frames.map((f) => {
+      const safeName = `${namePrefix}-${f.label}`.replace(/[^a-zA-Z0-9._-]+/g, "-");
+      const filePath = path.join(SCREENSHOT_DIR, `${safeName}.png`);
+      fs.writeFileSync(filePath, decodePngDataUrl(f.dataUrl));
+      return {
+        label: f.label,
+        offsetMs: f.offsetMs,
+        actualMs: f.actualMs,
+        path: filePath
+      };
+    });
+  },
+  // batched multi-stage capture for animation diffs. all N captures happen
+  // inside one page.evaluate round trip so browser-side timing controls the
+  // offsets — sidesteps the ~300ms per-call bridge overhead that blows
+  // sub-second animation windows. each stage gets a screenshot at the
+  // requested offsetMs (from when the evaluate starts, i.e. right after
+  // trigger() returns). returns absolute paths in stage order.
+  async takeScreenshotStages(namePrefix, stages) {
+    const page = getPage();
+    const frames = await page.evaluate(
+      async (input) => {
+        const screenshot = window.SootSim?.bridges?.screenshot;
+        if (typeof screenshot !== "function") {
+          throw new Error("sootsim screenshot bridge is not installed");
+        }
+        const start = Date.now();
+        const out = [];
+        for (const stage of input.stages) {
+          const elapsed = Date.now() - start;
+          const wait = Math.max(0, stage.offsetMs - elapsed);
+          if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+          const actualMs = Date.now() - start;
+          const dataUrl = await screenshot();
+          out.push({ label: stage.label, offsetMs: stage.offsetMs, actualMs, dataUrl });
+        }
+        return out;
+      },
+      { stages }
+    );
+    ensureScreenshotDir();
+    return frames.map((f) => {
+      const safeName = `${namePrefix}-${f.label}`.replace(/[^a-zA-Z0-9._-]+/g, "-");
+      const filePath = path.join(SCREENSHOT_DIR, `${safeName}.png`);
+      fs.writeFileSync(filePath, decodePngDataUrl(f.dataUrl));
+      return {
+        label: f.label,
+        offsetMs: f.offsetMs,
+        actualMs: f.actualMs,
+        path: filePath
+      };
+    });
+  },
+  async shake() {
+  },
+  async setLocation(lat, lon) {
+  },
+  async setStatusBar(config) {
+    await dispatchStatusBarOverride(config);
+  },
+  async setURLBlacklist(urls) {
+  },
+  async enableSynchronization() {
+    _synchronizationEnabled = true;
+  },
+  async disableSynchronization() {
+    _synchronizationEnabled = false;
+  },
+  getPlatform() {
+    return device._platform;
+  },
+  async pressBack() {
+    if (device._platform !== "android") return;
+    await element(by.id("android-nav-back")).tap();
+  },
+  // raw coordinate tap, bypassing the element-based visibility/hit-test path.
+  // mirrors detox 20.x device.tap({ x, y }) on real iOS — used when the
+  // target is occluded by a native UIWindow (e.g. UIMenu's dim layer) so
+  // `element(...).tap({x,y})` would fail Detox's visibility threshold.
+  async tap(point) {
+    if (point == null || typeof point === "boolean") return;
+    const page = getPage();
+    const { x, y } = point;
+    await page.evaluate(
+      async ({ x: tx, y: ty }) => {
+        const interactTap = window.SootSim?.bridges?.interact?.tap;
+        if (typeof interactTap === "function") {
+          const result = await interactTap(tx, ty);
+          if (result && (typeof result !== "object" || result.hit !== false)) return;
+        }
+        const tap = window.__sootsimTest?.tap;
+        if (typeof tap !== "function") {
+          throw new Error("sootsim tap bridge is not installed");
+        }
+        await tap(tx, ty);
+      },
+      { x, y }
+    );
+    await page.waitForTimeout(50);
+    if (_synchronizationEnabled) {
+      await waitForSootsimIdle(page);
+    }
+  },
+  async sendToHome() {
+  },
+  // get direct access to the playwright page for advanced use
+  getPage() {
+    return getPage();
+  }
+};
+var sootExpect = createExpect(findNodeByMatcher, getPage);
+var sootWaitFor = createWaitFor(findNodeByMatcher, getPage);
+async function cleanup() {
+  if (_browser) {
+    await _browser.close();
+    _browser = null;
+    _page = null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  by,
+  cleanup,
+  device,
+  element,
+  expect,
+  waitFor
+});