rnxsim 0.0.0 → 0.1.313

package/dist-lib/detox/index.cjs

@@ -0,0 +1,2863 @@
+/*! rnx v0.1.313 | (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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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/motion-change.cjs
+var require_motion_change = __commonJS({
+  "detox/motion-change.cjs"(exports2, module2) {
+    "use strict";
+    var MOTION_CHANGE_DEFINITION2 = Object.freeze({
+      channelThreshold: 24,
+      minimumChangePercent: 0.1
+    });
+    function measureMotionChange2(input) {
+      if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("motion change measurement requires an input object");
+      }
+      if (input.installGlobal === true) {
+        globalThis.__sootsimMeasureMotionChange = measureMotionChange2;
+        return null;
+      }
+      const definition = input.definition;
+      if (!definition || typeof definition !== "object" || !Number.isInteger(definition.channelThreshold) || definition.channelThreshold < 0 || definition.channelThreshold > 255 || !Number.isFinite(definition.minimumChangePercent) || definition.minimumChangePercent <= 0 || definition.minimumChangePercent >= 100) {
+        throw new Error(
+          "motion change definition needs a channel threshold from 0 to 255 and a minimum greater than 0% and less than 100%"
+        );
+      }
+      const label = typeof input.label === "string" && input.label.length > 0 ? input.label : "motion change";
+      let changePixels = input.changePixels;
+      let totalPixels = input.totalPixels;
+      if (input.baseline !== void 0 || input.candidate !== void 0) {
+        const baseline = input.baseline;
+        const candidate = input.candidate;
+        const width = input.width;
+        const height = input.height;
+        if (!baseline || !candidate || typeof baseline.length !== "number" || typeof candidate.length !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+          throw new Error(`${label} needs two RGBA pixel arrays and positive dimensions`);
+        }
+        totalPixels = width * height;
+        const expectedBytes = totalPixels * 4;
+        if (baseline.length !== expectedBytes || candidate.length !== expectedBytes) {
+          throw new Error(
+            `${label} pixel data has ${baseline.length}/${candidate.length} bytes; expected ${expectedBytes}`
+          );
+        }
+        changePixels = 0;
+        for (let offset = 0; offset < expectedBytes; offset += 4) {
+          if (Math.abs(baseline[offset] - candidate[offset]) > definition.channelThreshold || Math.abs(baseline[offset + 1] - candidate[offset + 1]) > definition.channelThreshold || Math.abs(baseline[offset + 2] - candidate[offset + 2]) > definition.channelThreshold || Math.abs(baseline[offset + 3] - candidate[offset + 3]) > definition.channelThreshold) {
+            changePixels++;
+          }
+        }
+      }
+      if (!Number.isInteger(totalPixels) || totalPixels <= 0) {
+        throw new Error(`${label} has no positive measured region area`);
+      }
+      if (!Number.isInteger(changePixels) || changePixels < 0 || changePixels > totalPixels) {
+        throw new Error(
+          `${label} changed pixel count ${changePixels} is outside its ${totalPixels}px measured region`
+        );
+      }
+      const changePercent = changePixels / totalPixels * 100;
+      return {
+        changePercent,
+        changePixels,
+        passedMinimum: changePercent >= definition.minimumChangePercent,
+        totalPixels
+      };
+    }
+    function measureProofMotionChange(input) {
+      return measureMotionChange2({
+        ...input,
+        definition: MOTION_CHANGE_DEFINITION2
+      });
+    }
+    module2.exports = {
+      MOTION_CHANGE_DEFINITION: MOTION_CHANGE_DEFINITION2,
+      measureMotionChange: measureMotionChange2,
+      measureProofMotionChange
+    };
+  }
+});
+
+// detox/index.ts
+var detox_exports = {};
+__export(detox_exports, {
+  by: () => by,
+  cleanup: () => cleanup,
+  device: () => device,
+  element: () => element,
+  expect: () => sootsimExpect,
+  waitFor: () => sootsimWaitFor,
+  waitForSootsimIdle: () => waitForSootsimIdle
+});
+module.exports = __toCommonJS(detox_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_playwright = require("playwright");
+
+// ../../scripts/lib/reap-browser.ts
+var import_node_child_process = require("node:child_process");
+var discoveredChromePids = /* @__PURE__ */ new WeakMap();
+var reapPids = /* @__PURE__ */ new Set();
+var installed = false;
+function currentRuntime() {
+  return { platform: process.platform, env: process.env };
+}
+function processCommand(pid) {
+  return (0, import_node_child_process.execFileSync)("/bin/ps", ["-p", String(pid), "-o", "command="], {
+    encoding: "utf8"
+  }).trim();
+}
+function softwareChromeAllowed(runtime = currentRuntime()) {
+  return runtime.platform === "linux" && runtime.env.GITHUB_ACTIONS === "true" && runtime.env.RUNNER_OS === "Linux";
+}
+function isSoftwareRendererArgument(value) {
+  const arg = String(value);
+  return /^--disable-gpu(?:=.*)?$/i.test(arg) || /^--enable-unsafe-swiftshader(?:=.*)?$/i.test(arg) || /^--use-angle=(?:swiftshader|swiftshader-webgl)$/i.test(arg) || /^--use-gl=swiftshader$/i.test(arg);
+}
+function softwareRendererArgumentInText(command) {
+  const unsafe = command.match(
+    /(?:^|\s)(--disable-gpu(?:=[^\s]+)?|--enable-unsafe-swiftshader(?:=[^\s]+)?|--use-angle=(?:swiftshader|swiftshader-webgl)|--use-gl=swiftshader)(?=\s|$)/i
+  );
+  return unsafe?.[1] ?? null;
+}
+function expectedAngle(platform) {
+  if (platform === "darwin") return "metal";
+  if (platform === "linux") return "vulkan";
+  return "default";
+}
+function assertGpuBrowserCommand(command, runtime = currentRuntime()) {
+  if (softwareChromeAllowed(runtime)) return;
+  const unsafe = softwareRendererArgumentInText(command);
+  if (unsafe) {
+    throw new Error(
+      `[reap-browser] refused software-rendering Chrome process argument ${unsafe}`
+    );
+  }
+  const angle = expectedAngle(runtime.platform);
+  const args = command.split(/\s+/);
+  if (!args.includes(`--use-angle=${angle}`) || !args.includes("--enable-gpu")) {
+    throw new Error(
+      `[reap-browser] Chrome process did not retain the required ${angle} GPU arguments`
+    );
+  }
+  if (runtime.platform === "darwin" && command.includes("/Applications/Google Chrome.app/")) {
+    throw new Error(
+      "[reap-browser] refused the user's installed Google Chrome; use Playwright channel chromium"
+    );
+  }
+}
+function collectGpuRendererStrings(info) {
+  if (!info || typeof info !== "object") return [];
+  const record = info;
+  const gpu = record.gpu;
+  if (!gpu || typeof gpu !== "object") return [];
+  const gpuRecord = gpu;
+  const values = [];
+  const aux = gpuRecord.auxAttributes;
+  if (aux && typeof aux === "object") {
+    for (const value of Object.values(aux)) {
+      if (typeof value === "string") values.push(value);
+    }
+  }
+  const devices = gpuRecord.devices;
+  if (Array.isArray(devices)) {
+    for (const device2 of devices) {
+      if (!device2 || typeof device2 !== "object") continue;
+      for (const value of Object.values(device2)) {
+        if (typeof value === "string") values.push(value);
+      }
+    }
+  }
+  return values;
+}
+function browserProcessPid(info) {
+  if (!info || typeof info !== "object") return null;
+  const record = info;
+  if (!Array.isArray(record.processInfo)) return null;
+  for (const entry of record.processInfo) {
+    if (!entry || typeof entry !== "object") continue;
+    const processInfo = entry;
+    if (processInfo.type === "browser" && typeof processInfo.id === "number" && Number.isInteger(processInfo.id) && processInfo.id > 0) {
+      return processInfo.id;
+    }
+  }
+  return null;
+}
+function assertGpuRendererInfo(info, runtime = currentRuntime()) {
+  if (softwareChromeAllowed(runtime)) return;
+  const renderers = collectGpuRendererStrings(info);
+  const summary = renderers.join(" | ");
+  if (!summary || /swiftshader|llvmpipe|software rasterizer/i.test(summary)) {
+    throw new Error(
+      `[reap-browser] Chrome reported a software renderer${summary ? `: ${summary}` : ""}`
+    );
+  }
+  if (runtime.platform === "darwin" && !/metal/i.test(summary)) {
+    throw new Error(
+      `[reap-browser] Chrome did not report an ANGLE Metal renderer: ${summary}`
+    );
+  }
+}
+function rootChromePid(b) {
+  if (b && typeof b === "object") {
+    const discovered = discoveredChromePids.get(b);
+    if (discovered !== void 0) return discovered;
+  }
+  const w = b;
+  if (w && typeof w.process === "function") {
+    try {
+      const p = w.process();
+      if (p && typeof p.pid === "number" && p.pid > 0) return p.pid;
+    } catch {
+    }
+  }
+  if (w && typeof w.browser === "function") {
+    try {
+      const child = w.browser();
+      if (child) return rootChromePid(child);
+    } catch {
+    }
+  }
+  return null;
+}
+function killTree(pid) {
+  let kids = [];
+  try {
+    kids = (0, import_node_child_process.execSync)(`pgrep -P ${pid} || true`).toString().split("\n").filter(Boolean);
+  } catch {
+  }
+  for (const k of kids) killTree(Number(k));
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+function browserControl(b) {
+  const candidate = b;
+  if (!candidate || typeof candidate !== "object") return null;
+  if (typeof candidate.newBrowserCDPSession === "function" || typeof candidate.process === "function") {
+    return candidate;
+  }
+  if (typeof candidate.browser !== "function") return null;
+  try {
+    const browser = candidate.browser();
+    return browser ? browserControl(browser) : null;
+  } catch {
+    return null;
+  }
+}
+function registerChromePid(browser, control, pid) {
+  if (browser && typeof browser === "object") discoveredChromePids.set(browser, pid);
+  discoveredChromePids.set(control, pid);
+  reapPids.add(pid);
+  installReaper();
+}
+async function discoverChromePid(browser) {
+  const known = rootChromePid(browser);
+  if (known !== null) return known;
+  const control = browserControl(browser);
+  if (!control || typeof control.newBrowserCDPSession !== "function") return null;
+  const session = await control.newBrowserCDPSession();
+  try {
+    const pid = browserProcessPid(await session.send("SystemInfo.getProcessInfo"));
+    if (pid === null) return null;
+    registerChromePid(browser, control, pid);
+    return pid;
+  } finally {
+    await session.detach?.();
+  }
+}
+async function rejectLaunchedBrowser(browser) {
+  const root = rootChromePid(browser);
+  if (root !== null) {
+    reapPids.delete(root);
+    killTree(root);
+    return;
+  }
+  const candidate = browser;
+  if (candidate && typeof candidate.close === "function") {
+    try {
+      await candidate.close();
+    } catch {
+    }
+  }
+}
+async function validateLaunchedGpuBrowser(browser, runtime, rendererTarget, commandForPid = processCommand) {
+  if (softwareChromeAllowed(runtime)) return;
+  const root = rootChromePid(browser);
+  const launchedControl = browserControl(browser);
+  if (root !== null && launchedControl) {
+    registerChromePid(browser, launchedControl, root);
+  }
+  if (root !== null && (runtime.platform === "darwin" || runtime.platform === "linux")) {
+    assertGpuBrowserCommand(commandForPid(root), runtime);
+  }
+  const rendererBrowser = rendererTarget ? await rendererTarget(browser) : browser;
+  const control = browserControl(rendererBrowser);
+  if (control && typeof control.newBrowserCDPSession === "function") {
+    const session = await control.newBrowserCDPSession();
+    try {
+      const pid = browserProcessPid(await session.send("SystemInfo.getProcessInfo"));
+      if (pid === null) {
+        throw new Error("[reap-browser] Chrome did not report its browser process id");
+      }
+      registerChromePid(browser, control, pid);
+      if (rendererBrowser && typeof rendererBrowser === "object") {
+        discoveredChromePids.set(rendererBrowser, pid);
+      }
+      if (runtime.platform === "darwin" || runtime.platform === "linux") {
+        assertGpuBrowserCommand(commandForPid(pid), runtime);
+      }
+      assertGpuRendererInfo(await session.send("SystemInfo.getInfo"), runtime);
+      return;
+    } finally {
+      await session.detach?.();
+    }
+  }
+  throw new Error("[reap-browser] could not validate the launched Chrome GPU renderer");
+}
+var signalShutdownClaimed = false;
+function installReaper() {
+  if (installed) return;
+  installed = true;
+  const reap = () => {
+    for (const pid of reapPids) killTree(pid);
+  };
+  if (!signalShutdownClaimed) {
+    process.on("SIGTERM", () => {
+      reap();
+      process.exit(0);
+    });
+    process.on("SIGINT", () => {
+      reap();
+      process.exit(0);
+    });
+  }
+  process.on("exit", reap);
+}
+async function launchReapedScoped(launch) {
+  const browser = await launch();
+  let root = rootChromePid(browser);
+  if (root === null) {
+    try {
+      root = await discoverChromePid(browser);
+    } catch {
+      root = null;
+    }
+  }
+  const mine = /* @__PURE__ */ new Set();
+  if (root != null) {
+    mine.add(root);
+    reapPids.add(root);
+    installReaper();
+  }
+  const evented = browserControl(browser) ?? browser;
+  if (typeof evented.on === "function") {
+    const disconnectEvent = typeof evented.newBrowserCDPSession === "function" ? "disconnected" : "close";
+    evented.on(disconnectEvent, () => {
+      for (const pid of mine) reapPids.delete(pid);
+      mine.clear();
+    });
+  }
+  const reapNow = () => {
+    for (const pid of mine) {
+      killTree(pid);
+      reapPids.delete(pid);
+    }
+    mine.clear();
+  };
+  return { browser, reapNow };
+}
+function gpuChromeArgs(platform = process.platform) {
+  const angle = expectedAngle(platform);
+  return [
+    // sootsim's compositor renders through skia graphite on webgpu, so a launch
+    // without navigator.gpu cannot present a frame at all. chrome enables webgpu
+    // by default on gpu-backed macOS but not on every headless configuration,
+    // and every caller that renders a sim was passing this by hand. own it here
+    // so a launcher cannot silently come up without the only backend there is.
+    "--enable-unsafe-webgpu",
+    `--use-angle=${angle}`,
+    "--enable-gpu",
+    "--enable-gpu-rasterization",
+    "--enable-zero-copy",
+    "--ignore-gpu-blocklist"
+  ];
+}
+function gpuChromeLaunchOptions(opts = {}, runtime = currentRuntime()) {
+  const callerArgs = Array.isArray(opts.args) ? opts.args : [];
+  const unsafe = callerArgs.find(isSoftwareRendererArgument);
+  if (unsafe !== void 0) {
+    throw new Error(
+      `[reap-browser] refused software-rendering Chrome launch argument ${String(unsafe)}`
+    );
+  }
+  if (opts.executablePath !== void 0) {
+    throw new Error(
+      "[reap-browser] executablePath bypasses Playwright Chrome for Testing and is not allowed"
+    );
+  }
+  if (opts.ignoreDefaultArgs === true) {
+    throw new Error(
+      "[reap-browser] ignoreDefaultArgs=true bypasses required Chrome launch defaults"
+    );
+  }
+  const managedGpuArgs = /* @__PURE__ */ new Set([
+    "--enable-unsafe-webgpu",
+    "--enable-gpu",
+    "--enable-gpu-rasterization",
+    "--enable-zero-copy",
+    "--ignore-gpu-blocklist"
+  ]);
+  const unmanagedCallerArgs = callerArgs.filter((arg) => {
+    const value = String(arg);
+    return !managedGpuArgs.has(value) && !value.startsWith("--use-angle=");
+  });
+  const callerIgnored = Array.isArray(opts.ignoreDefaultArgs) ? opts.ignoreDefaultArgs : [];
+  const ignoredDefaults = [
+    .../* @__PURE__ */ new Set([...callerIgnored, "--disable-gpu", "--enable-unsafe-swiftshader"])
+  ];
+  return {
+    ...opts,
+    // playwright's `chromium` channel is the full Google Chrome for Testing
+    // app, not chromium_headless_shell. on macOS it has bundle id
+    // com.google.chrome.for.testing, so automation cannot become the target of
+    // Dock open/quit events intended for the user's com.google.Chrome browser.
+    channel: "chromium",
+    args: [...unmanagedCallerArgs, ...gpuChromeArgs(runtime.platform)],
+    ignoreDefaultArgs: ignoredDefaults
+  };
+}
+function platformChromeLaunch(launch, opts, rendererTarget, policy = {}) {
+  return async () => {
+    const runtime = policy.runtime ?? currentRuntime();
+    if (softwareChromeAllowed(runtime)) {
+      return launch(chromeLaunchOptions(opts, runtime));
+    }
+    const gpuOptions = chromeLaunchOptions(opts, runtime);
+    let browser;
+    try {
+      browser = await launch(gpuOptions);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const missing = /not found at|not installed|Chromium distribution|Executable doesn't exist|No such file/i.test(
+        msg
+      );
+      if (!missing) throw err;
+      throw new Error(
+        "[reap-browser] Playwright Chrome for Testing is required for local GPU browser work. Run `bun scripts/ops/install-playwright-browsers.ts chromium`.",
+        { cause: err }
+      );
+    }
+    try {
+      await validateLaunchedGpuBrowser(
+        browser,
+        runtime,
+        rendererTarget,
+        policy.processCommand
+      );
+    } catch (err) {
+      await rejectLaunchedBrowser(browser);
+      throw err;
+    }
+    return browser;
+  };
+}
+function softwareChromeLaunchOptions(opts) {
+  if (opts.ignoreDefaultArgs === true) {
+    throw new Error(
+      "[reap-browser] ignoreDefaultArgs=true bypasses required Chrome launch defaults"
+    );
+  }
+  const callerArgs = Array.isArray(opts.args) ? opts.args.map(String) : [];
+  const unmanagedCallerArgs = callerArgs.filter((arg) => {
+    return !arg.startsWith("--use-angle=") && arg !== "--enable-gpu" && arg !== "--enable-gpu-rasterization" && arg !== "--enable-zero-copy" && arg !== "--ignore-gpu-blocklist" && !/^--enable-unsafe-webgpu(?:=.*)?$/i.test(arg) && !/^--enable-features=(?:Vulkan|WebGPU)(?:,(?:Vulkan|WebGPU))*$/i.test(arg) && !/^--enable-unsafe-swiftshader(?:=.*)?$/i.test(arg);
+  });
+  const software = {
+    ...opts,
+    args: [
+      ...unmanagedCallerArgs,
+      "--use-angle=swiftshader",
+      "--enable-unsafe-swiftshader",
+      // playwright's bundled software chromium exposes no navigator.gpu without
+      // these two, and the compositor's only backend is webgpu. emitted here
+      // rather than per caller so a hosted-linux launch and a local gpu launch
+      // agree on what a sim needs.
+      "--enable-unsafe-webgpu",
+      "--enable-features=Vulkan"
+    ]
+  };
+  delete software.channel;
+  delete software.executablePath;
+  return software;
+}
+function chromeLaunchOptions(opts = {}, runtime = currentRuntime()) {
+  return softwareChromeAllowed(runtime) ? softwareChromeLaunchOptions(opts) : gpuChromeLaunchOptions(opts, runtime);
+}
+async function launchReapedChromeScoped(launch, opts = {}, rendererTarget, policy = {}) {
+  return launchReapedScoped(platformChromeLaunch(launch, opts, rendererTarget, policy));
+}
+
+// src/poll-until.ts
+async function pollUntil(read, ready, options) {
+  if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+    throw new Error("poll timeout must be a positive finite number");
+  }
+  const intervalMs = options.intervalMs ?? 100;
+  if (!Number.isFinite(intervalMs) || intervalMs < 0) {
+    throw new Error("poll interval must be a non-negative finite number");
+  }
+  const deadline = Date.now() + options.timeoutMs;
+  let lastError;
+  const timeoutError = () => new Error(`${options.label} timed out after ${options.timeoutMs}ms`, {
+    cause: lastError
+  });
+  options.signal?.throwIfAborted();
+  let rejectBoundary = () => {
+  };
+  const boundary = new Promise((_, reject) => {
+    rejectBoundary = reject;
+  });
+  const onAbort = () => rejectBoundary(
+    options.signal?.reason ?? new DOMException("The operation was aborted", "AbortError")
+  );
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  const deadlineTimer = setTimeout(
+    () => rejectBoundary(timeoutError()),
+    options.timeoutMs
+  );
+  try {
+    while (true) {
+      if (Date.now() >= deadline) throw timeoutError();
+      const outcome = await Promise.race([
+        Promise.resolve().then(read).then(
+          (value) => ({ kind: "value", value }),
+          (error) => ({ kind: "error", error })
+        ),
+        boundary
+      ]);
+      options.signal?.throwIfAborted();
+      if (outcome.kind === "error") {
+        lastError = outcome.error;
+      } else {
+        if (Date.now() >= deadline) throw timeoutError();
+        try {
+          if (ready(outcome.value)) return outcome.value;
+        } catch (error) {
+          lastError = error;
+        }
+      }
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) throw timeoutError();
+      if (intervalMs > 0) {
+        let intervalTimer;
+        try {
+          await Promise.race([
+            new Promise((resolve) => {
+              intervalTimer = setTimeout(resolve, Math.min(intervalMs, remaining));
+            }),
+            boundary
+          ]);
+        } finally {
+          clearTimeout(intervalTimer);
+        }
+      }
+    }
+  } finally {
+    clearTimeout(deadlineTimer);
+    options.signal?.removeEventListener("abort", onAbort);
+  }
+}
+
+// detox/gestures.ts
+async function waitForSootsimGestureHandler(page, viewTag, handlerName) {
+  await pollUntil(
+    () => page.evaluate(
+      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 }
+    ),
+    Boolean,
+    {
+      timeoutMs: 5e3,
+      intervalMs: 100,
+      label: `${handlerName} gesture handler on view ${viewTag}`
+    }
+  );
+}
+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, timeoutMs) {
+  if (!before) {
+    await page.waitForTimeout(250);
+    return;
+  }
+  let lastShellSent = before.shellSent;
+  let stableSince = Date.now();
+  let sawCallback = false;
+  await pollUntil(
+    () => readWorkletCallbackStats(page),
+    (current) => {
+      if (!current) return false;
+      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;
+      return sawCallback && receivedDelta >= sentDelta && Date.now() - stableSince >= 100;
+    },
+    {
+      timeoutMs,
+      intervalMs: 20,
+      label: "worklet callback drain"
+    }
+  ).catch(() => {
+  });
+  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, timeoutMs) {
+  await ensureCanvasFinder(page);
+  try {
+    const metrics = await pollUntil(
+      () => 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
+          }
+        };
+      }),
+      (metrics2) => metrics2 !== null,
+      {
+        timeoutMs,
+        intervalMs: 50,
+        label: "sootsim surface metrics"
+      }
+    );
+    if (metrics === null) throw new Error("surface metrics poll settled without metrics");
+    return metrics;
+  } catch (error) {
+    throw new Error("sootsim surface metrics are not available", { cause: error });
+  }
+}
+async function readSootsimViewport(page, timeoutMs = 5e3) {
+  return (await readSootsimPageMetrics(page, timeoutMs)).window;
+}
+async function readSootsimInteractiveViewport(page, timeoutMs = 5e3) {
+  return (await readSootsimPageMetrics(page, timeoutMs)).interactiveWindow;
+}
+async function sootsimToPage(page, sootsimX, sootsimY, timeoutMs = 5e3) {
+  const metrics = await readSootsimPageMetrics(page, timeoutMs);
+  const scaleX = metrics.canvas.width / metrics.window.width;
+  const scaleY = metrics.canvas.height / metrics.window.height;
+  return {
+    x: metrics.canvas.left + sootsimX * scaleX,
+    y: metrics.canvas.top + sootsimY * scaleY
+  };
+}
+async function dragScrollNode(page, node, pixels, direction) {
+  const startSootSimX = node.absolutePosition.x + node.layout.width / 2;
+  const startSootSimY = node.absolutePosition.y + node.layout.height / 2;
+  let endSootSimX = startSootSimX;
+  let endSootSimY = startSootSimY;
+  switch (direction) {
+    case "down":
+      endSootSimY -= pixels;
+      break;
+    case "up":
+      endSootSimY += pixels;
+      break;
+    case "left":
+      endSootSimX += pixels;
+      break;
+    case "right":
+      endSootSimX -= pixels;
+      break;
+  }
+  const startPage = await sootsimToPage(page, startSootSimX, startSootSimY);
+  const endPage = await sootsimToPage(page, endSootSimX, endSootSimY);
+  const steps = Math.max(16, Math.ceil(pixels / 8));
+  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(24);
+  }
+  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;
+  const workletStatsTimeoutMs = options.workletStatsTimeoutMs ?? 1500;
+  await ensureCanvasFinder(page);
+  const beforeWorkletStats = await pollUntil(
+    () => readWorkletCallbackStats(page),
+    () => true,
+    {
+      timeoutMs: workletStatsTimeoutMs,
+      intervalMs: 0,
+      label: "pre-dispatch worklet callback stats"
+    }
+  ).catch(() => null);
+  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, workletStatsTimeoutMs);
+  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)}`);
+  }
+  const before = scrollOffsetOf(node);
+  await dragScrollNode(page, node, pixels, direction);
+  const after = scrollOffsetOf(await findNode(matcher));
+  return Math.abs(after.x - before.x) + Math.abs(after.y - before.y);
+}
+function scrollOffsetOf(node) {
+  return { x: node?.scrollOffsetX ?? 0, y: node?.scrollOffsetY ?? 0 };
+}
+function visibleFraction(node) {
+  const totalArea = (node?.layout?.width ?? 0) * (node?.layout?.height ?? 0);
+  const frame = node?.visibleFrame;
+  if (totalArea <= 0 || !frame) return 0;
+  const visibleArea = Math.max(0, frame.width) * Math.max(0, frame.height);
+  return visibleArea / totalArea;
+}
+function isNodeVisible(node) {
+  return visibleFraction(node) >= DEFAULT_VISIBILITY_THRESHOLD;
+}
+async function isNodeFocused(node, page) {
+  const nodeId = typeof node?.nodeId === "number" ? node.nodeId : typeof node?.id === "number" ? node.id : null;
+  if (nodeId === null) return false;
+  return page.evaluate((id) => {
+    const active = document.activeElement;
+    return active?.getAttribute("data-sootsim-id") === String(id);
+  }, nodeId);
+}
+function describeNodeVisibility(node) {
+  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,
+    visibleFraction: visibleFraction(node),
+    threshold: DEFAULT_VISIBILITY_THRESHOLD,
+    style: node.style ?? null
+  });
+}
+function createExpect(findNode, getPage2) {
+  return function sootsimExpect2(el) {
+    return new SootSimExpectation(el._matcher, findNode, getPage2, false);
+  };
+}
+var SootSimExpectation = class _SootSimExpectation {
+  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 _SootSimExpectation(
+      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 visible = isNodeVisible(node);
+    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)}: ${JSON.stringify(this.matcher)}`
+        );
+      }
+    }
+  }
+  async toBeNotVisible() {
+    const node = await this.findNode(this.matcher);
+    const visible = isNodeVisible(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() {
+    const node = await this.findNode(this.matcher);
+    if (!node) {
+      throw new Error(
+        `element not found for toBeFocused: ${JSON.stringify(this.matcher)}`
+      );
+    }
+    const focused = await isNodeFocused(node, this.getPage());
+    if (this.negated) {
+      if (focused) {
+        throw new Error(
+          `expected element NOT to be focused: ${JSON.stringify(this.matcher)}`
+        );
+      }
+    } else if (!focused) {
+      throw new Error(`expected element to be focused: ${JSON.stringify(this.matcher)}`);
+    }
+  }
+  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 sootsimWaitFor2(el) {
+    return new SootSimWaitForChain(el._matcher, findNode, getPage2);
+  };
+}
+var SootSimWaitForChain = 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 SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+  toBeVisible() {
+    this.assertionFn = async () => {
+      const node = await this.findNode(this.matcher);
+      const visible = isNodeVisible(node);
+      if (this._negated ? visible : !visible) {
+        throw new Error(
+          `waitFor toBeVisible failed (${describeNodeVisibility(node)}): ${JSON.stringify(this.matcher)}`
+        );
+      }
+    };
+    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+  toBeNotVisible() {
+    this.assertionFn = async () => {
+      const node = await this.findNode(this.matcher);
+      const visible = isNodeVisible(node);
+      if (visible) {
+        throw new Error(`waitFor toBeNotVisible failed: ${JSON.stringify(this.matcher)}`);
+      }
+    };
+    return new SootSimWaitForAction(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 SootSimWaitForAction(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 SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+  toBeFocused() {
+    this.assertionFn = async () => {
+      const node = await this.findNode(this.matcher);
+      if (!node)
+        throw new Error(
+          `waitFor toBeFocused: element not found: ${JSON.stringify(this.matcher)}`
+        );
+      const focused = await isNodeFocused(node, this.getPage());
+      if (this._negated ? focused : !focused) {
+        throw new Error(`waitFor toBeFocused failed: ${JSON.stringify(this.matcher)}`);
+      }
+    };
+    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
+  }
+};
+var SootSimWaitForAction = 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 SootSimWaitForScrollAction(
+      this.assertionFn,
+      this.findNode,
+      this.getPage,
+      matcher
+    );
+  }
+};
+var SootSimWaitForScrollAction = class {
+  assertionFn;
+  findNode;
+  getPage;
+  matcher;
+  constructor(assertionFn, findNode, getPage2, matcher) {
+    this.assertionFn = assertionFn;
+    this.findNode = findNode;
+    this.getPage = getPage2;
+    this.matcher = matcher;
+  }
+  // detox scrolls the container until the expectation passes or the container
+  // can no longer move. bounding this by wall clock instead made the result
+  // depend on how fast the host dispatches pointer events: the same fixture and
+  // the same assertion pass on an idle machine and fail on a loaded one,
+  // because each 200px drag is a real pointer stream and fewer of them fit in
+  // the budget. end on scroll exhaustion, which is a property of the content.
+  async scroll(pixels, direction, _startPositionX, _startPositionY) {
+    const page = this.getPage();
+    let lastError = null;
+    let stalledSteps = 0;
+    while (stalledSteps < 2) {
+      try {
+        await this.assertionFn();
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+      const travelled = await scrollMatcherElement(
+        page,
+        this.findNode,
+        this.matcher,
+        pixels,
+        direction
+      );
+      stalledSteps = travelled < 0.5 ? stalledSteps + 1 : 0;
+    }
+    throw lastError || new Error(
+      `waitFor whileElement(...).scroll() reached the end of ${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 import_motion_change = __toESM(require_motion_change(), 1);
+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 _reapBrowserNow = 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 waitForSootsimSurfaceMetrics(page, timeout = 3e4) {
+  const deadline = Date.now() + timeout;
+  let lastSnapshot = null;
+  while (Date.now() < deadline) {
+    lastSnapshot = await page.evaluate(async () => {
+      const metricsWindow = (value) => {
+        if (!value || typeof value !== "object") return null;
+        const windowValue = value.window;
+        if (!windowValue || typeof windowValue !== "object") return null;
+        return windowValue;
+      };
+      const snapshot = await window.__sootsimTest?.getSurfaceMetricsSnapshot?.();
+      const windowMetrics = metricsWindow(snapshot);
+      const width = windowMetrics?.width;
+      const height = windowMetrics?.height;
+      if (typeof width === "number" && typeof height === "number" && width > 0 && height > 0) {
+        return { ready: true };
+      }
+      return { ready: false, snapshot };
+    });
+    if (lastSnapshot && typeof lastSnapshot === "object" && lastSnapshot.ready) {
+      return;
+    }
+    await page.waitForTimeout(50);
+  }
+  throw new Error(
+    `timed out waiting for sootsim surface metrics: ${JSON.stringify(lastSnapshot)}`
+  );
+}
+async function waitForSootsimShellReady(page, timeout = 3e4) {
+  try {
+    await page.evaluate(async (timeoutMs) => {
+      const start = Date.now();
+      const deadline = start + timeoutMs;
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      const remaining = () => Math.max(1, deadline - Date.now());
+      const withTimeout = async (label, promise) => {
+        let timer = null;
+        try {
+          await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+              timer = setTimeout(
+                () => reject(new Error(`${label} timed out after ${timeoutMs}ms`)),
+                remaining()
+              );
+            })
+          ]);
+        } finally {
+          if (timer) clearTimeout(timer);
+        }
+      };
+      const isTenantOnly = new URL(window.location.href).searchParams.get("renderMode") === "tenant-only";
+      const currentUrl = new URL(window.location.href);
+      const expectsInitialAppPaint = currentUrl.searchParams.has("test") || currentUrl.pathname.includes("/app/");
+      let shellHost = null;
+      while (Date.now() < deadline) {
+        const candidate = window.SootSim?.bridges?.shellHost;
+        if (candidate || isTenantOnly) {
+          shellHost = candidate ?? null;
+          break;
+        }
+        await sleep(25);
+      }
+      if (!shellHost) {
+        if (isTenantOnly) return;
+        throw new Error(`sootsim shell host unavailable after ${timeoutMs}ms`);
+      }
+      if (shellHost.ready && typeof shellHost.ready.then === "function") {
+        await withTimeout("sootsim shell ready", shellHost.ready);
+      }
+      if (!expectsInitialAppPaint && shellHost.firstContentPainted && typeof shellHost.firstContentPainted.then === "function") {
+        await withTimeout(
+          "sootsim shell first content paint",
+          shellHost.firstContentPainted
+        );
+      }
+      const waitForScreenTransitions = window.__sootsimTest?.waitForScreenTransitions;
+      if (typeof waitForScreenTransitions === "function") {
+        const transitionResult = await waitForScreenTransitions({
+          timeoutMs: Math.min(remaining(), 3e3),
+          settleMs: 64,
+          startWindowMs: 700
+        });
+        if (transitionResult?.timedOut === true) {
+          throw new Error(
+            `sootsim app launch transitions timed out: ${JSON.stringify(transitionResult)}`
+          );
+        }
+      }
+    }, timeout);
+  } catch (error) {
+    throw await describeSootsimBridgeFailure(page, error);
+  }
+}
+async function waitForSootsimWorkletsIdle(page, timeout = 3e3) {
+  const result = await page.evaluate(
+    async ({ timeout: timeout2 }) => {
+      const getPeerStats = window.__sootsimTest?.getPeerStats;
+      if (typeof getPeerStats !== "function") {
+        return { settled: true, skipped: true };
+      }
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      const readStats = () => Promise.race([
+        getPeerStats(false),
+        new Promise((resolve) => setTimeout(() => resolve(null), 250))
+      ]);
+      const start = Date.now();
+      const deadline = start + timeout2;
+      const requiredStableMs = 120;
+      let stableSince = null;
+      let lastPending = 0;
+      await sleep(0);
+      while (Date.now() < deadline) {
+        const stats = await readStats();
+        const pending = stats && typeof stats === "object" && typeof stats.pendingRunWorklets === "number" ? stats.pendingRunWorklets : 0;
+        lastPending = pending;
+        if (pending === 0) {
+          stableSince ??= Date.now();
+          if (Date.now() - stableSince >= requiredStableMs) {
+            return { settled: true, elapsed: Date.now() - start, pending };
+          }
+        } else {
+          stableSince = null;
+        }
+        await sleep(25);
+      }
+      return {
+        settled: false,
+        elapsed: Date.now() - start,
+        pending: lastPending
+      };
+    },
+    { timeout }
+  );
+  if (!result?.settled) {
+    throw new Error(
+      `sootsim worklet runtime did not settle after ${result?.elapsed ?? timeout}ms (pending=${result?.pending ?? "unknown"})`
+    );
+  }
+}
+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;
+  const reapBrowserNow = _reapBrowserNow;
+  _browser = null;
+  _reapBrowserNow = null;
+  await closeContext();
+  try {
+    await browser.close();
+  } finally {
+    reapBrowserNow?.();
+  }
+}
+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.index !== void 0) {
+    return page.evaluate(async (indexedMatcher) => {
+      const filter = indexedMatcher.type === "id" ? { hasId: indexedMatcher.value } : indexedMatcher.type === "text" ? { hasText: indexedMatcher.value } : indexedMatcher.type === "label" ? { hasLabel: indexedMatcher.value } : indexedMatcher.type === "role" ? { hasRole: indexedMatcher.value } : { type: indexedMatcher.value };
+      const results = await window.__sootsimTest.queryAll(filter);
+      return results[indexedMatcher.index ?? 0] ?? null;
+    }, matcher);
+  }
+  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 nodeOffsetToPage(page, nodeInfo, dx, dy) {
+  const center = getNodeCenter(nodeInfo);
+  return sootsimToPage(page, center.x + dx, center.y + dy);
+}
+async function getDefaultTapPoint(page, nodeInfo) {
+  const resolvedTarget = await page.evaluate(
+    (nodeId) => window.__sootsimTest?.resolveTapTarget?.(nodeId) ?? null,
+    nodeInfo.nodeId
+  );
+  const center = resolvedTarget && typeof resolvedTarget.cx === "number" && typeof resolvedTarget.cy === "number" ? { x: resolvedTarget.cx, y: resolvedTarget.cy } : getNodeCenter(nodeInfo);
+  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 fullFrameTolerance = 0.5;
+  const fullyVisible = typeof nodeInfo.absolutePosition?.x === "number" && typeof nodeInfo.absolutePosition?.y === "number" && typeof nodeInfo.layout?.width === "number" && typeof nodeInfo.layout?.height === "number" && Math.abs(frame.x - nodeInfo.absolutePosition.x) <= fullFrameTolerance && Math.abs(frame.y - nodeInfo.absolutePosition.y) <= fullFrameTolerance && frame.width >= nodeInfo.layout.width - fullFrameTolerance && frame.height >= nodeInfo.layout.height - fullFrameTolerance;
+  if (fullyVisible) return center;
+  const viewport = await readSootsimInteractiveViewport(page);
+  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 dispatchTapAtSootsimPoint(page, x, y) {
+  await page.evaluate(
+    async ({ x: x2, y: y2 }) => {
+      const interactTap = window.SootSim?.bridges?.interact?.tap;
+      if (typeof interactTap === "function") {
+        const result = await interactTap(x2, y2);
+        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(x2, y2);
+    },
+    { x, y }
+  );
+}
+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: ${JSON.stringify(dataUrl.slice(0, 120))}`
+    );
+  }
+  return Buffer.from(match[1], "base64");
+}
+function writeFastScreenshotFrames(namePrefix, frames) {
+  ensureScreenshotDir();
+  return frames.map((frame) => {
+    const safeName = `${namePrefix}-${frame.label}`.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    const filePath = path.join(SCREENSHOT_DIR, `${safeName}.png`);
+    fs.writeFileSync(filePath, decodePngDataUrl(frame.dataUrl));
+    const { dataUrl: _dataUrl, ...metadata } = frame;
+    return {
+      ...metadata,
+      path: filePath
+    };
+  });
+}
+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, format: "png" }
+  );
+  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,
+      format: "png"
+    }
+  );
+  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 createSootSimElement(matcher) {
+  const el = {
+    _matcher: matcher,
+    async tap(point) {
+      const page = getPage();
+      await waitForSootsimWorkletsIdle(page, 3e3);
+      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 targetSootSimX = typeof point?.x === "number" ? node.absolutePosition.x + point.x : defaultPoint?.x ?? node.absolutePosition.x + node.layout.width / 2;
+      const targetSootSimY = typeof point?.y === "number" ? node.absolutePosition.y + point.y : defaultPoint?.y ?? node.absolutePosition.y + node.layout.height / 2;
+      await dispatchTapAtSootsimPoint(page, targetSootSimX, targetSootSimY);
+      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);
+      await page.evaluate(
+        async ({ duration: duration2, x, y }) => {
+          const longPress = window.SootSim?.bridges?.interact?.longPress;
+          if (typeof longPress !== "function") {
+            throw new Error("sootsim longPress bridge is not installed");
+          }
+          const hit = await longPress(x, y, duration2);
+          if (!hit) {
+            throw new Error(`sootsim longPress missed at ${x},${y}`);
+          }
+        },
+        { duration, x: center.x, y: center.y }
+      );
+      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 startSootSimX = srcNode.absolutePosition.x + srcNode.layout.width * normalizedStartX;
+      const startSootSimY = srcNode.absolutePosition.y + srcNode.layout.height * normalizedStartY;
+      const endSootSimX = tgtNode.absolutePosition.x + tgtNode.layout.width * normalizedEndX;
+      const endSootSimY = tgtNode.absolutePosition.y + tgtNode.layout.height * normalizedEndY;
+      const startPage = await sootsimToPage(page, startSootSimX, startSootSimY);
+      const endPage = await sootsimToPage(page, endSootSimX, endSootSimY);
+      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, normalizedStartingPointX = 0.5, normalizedStartingPointY = 0.5) {
+      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 startSootSimX = absolutePosition.x + layout.width * normalizedStartingPointX;
+      const startSootSimY = absolutePosition.y + layout.height * normalizedStartingPointY;
+      let endSootSimX = startSootSimX;
+      let endSootSimY = startSootSimY;
+      const viewport = await readSootsimViewport(page);
+      const dist = direction === "up" || direction === "down" ? viewport.height * percentage : viewport.width * percentage;
+      switch (direction) {
+        case "up":
+          endSootSimY -= dist;
+          break;
+        case "down":
+          endSootSimY += dist;
+          break;
+        case "left":
+          endSootSimX -= dist;
+          break;
+        case "right":
+          endSootSimX += dist;
+          break;
+      }
+      const steps = speed === "slow" ? 40 : 20;
+      const stepDelay = 1e3 / 60;
+      await page.evaluate(
+        async ({ fromX, fromY, toX, toY, steps: steps2, stepMs }) => {
+          const drag = window.__sootsimInteract?.drag;
+          if (typeof drag !== "function") {
+            throw new Error("sootsim interact bridge is not installed");
+          }
+          await drag(fromX, fromY, toX, toY, steps2, stepMs);
+        },
+        {
+          fromX: startSootSimX,
+          fromY: startSootSimY,
+          toX: endSootSimX,
+          toY: endSootSimY,
+          steps,
+          stepMs: stepDelay
+        }
+      );
+      await page.waitForTimeout(100);
+    },
+    async setColumnToValue(column, value) {
+      if (!Number.isInteger(column) || column < 0) {
+        throw new Error(`picker column must be a non-negative integer, got ${column}`);
+      }
+      if (typeof value !== "string") {
+        throw new Error(`picker value must be a string, got ${typeof value}`);
+      }
+      const picker = await findNodeByMatcher(matcher);
+      if (!picker) {
+        throw new Error(
+          `element not found for setColumnToValue: ${JSON.stringify(matcher)}`
+        );
+      }
+      const page = getPage();
+      const candidates = await page.evaluate(
+        async ({ picker: picker2, column: column2, value: value2 }) => {
+          const result = await window.__sootsimTest?.queryTextCandidates?.({
+            query: value2,
+            exact: true
+          });
+          if (!result || !Array.isArray(result.candidates)) return [];
+          const left = picker2.absolutePosition.x;
+          const top = picker2.absolutePosition.y;
+          const right = left + picker2.layout.width;
+          const bottom = top + picker2.layout.height;
+          return result.candidates.filter((candidate) => candidate.ancestorPickerColumnIndices.includes(column2)).map((candidate) => candidate.info).filter((candidate) => {
+            const x = candidate.absolutePosition?.x;
+            const y = candidate.absolutePosition?.y;
+            const width = candidate.layout?.width;
+            const height = candidate.layout?.height;
+            if (typeof x !== "number" || typeof y !== "number" || typeof width !== "number" || typeof height !== "number") {
+              return false;
+            }
+            const centerX = x + width / 2;
+            const centerY = y + height / 2;
+            return centerX >= left && centerX <= right && centerY >= top && centerY <= bottom;
+          });
+        },
+        { picker, column, value }
+      );
+      if (candidates.length !== 1) {
+        throw new Error(
+          `setColumnToValue(${column}, ${JSON.stringify(value)}) found ${candidates.length} matching rows inside ${JSON.stringify(matcher)}`
+        );
+      }
+      const target = candidates[0];
+      const tapTarget = await page.evaluate(
+        async (nodeId) => window.__sootsimTest?.resolveTapTarget(nodeId),
+        target.nodeId
+      );
+      if (!tapTarget) {
+        throw new Error(
+          `setColumnToValue(${column}, ${JSON.stringify(value)}) could not resolve its picker row`
+        );
+      }
+      await dispatchTapAtSootsimPoint(
+        page,
+        tapTarget.target.absolutePosition.x + tapTarget.target.layout.width / 2,
+        tapTarget.target.absolutePosition.y + tapTarget.target.layout.height / 2
+      );
+    },
+    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 startSpread = Math.min(
+        60,
+        Math.max(12, Math.min(node.layout.width, node.layout.height) * 0.25)
+      );
+      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,
+        await nodeOffsetToPage(page, node, a0.dx, a0.dy),
+        await nodeOffsetToPage(page, node, b0.dx, b0.dy),
+        await nodeOffsetToPage(page, node, a1.dx, a1.dy),
+        await nodeOffsetToPage(page, node, b1.dx, 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 radius = Math.min(
+        60,
+        Math.max(12, Math.min(node.layout.width, node.layout.height) * 0.25)
+      );
+      const startA = await nodeOffsetToPage(page, node, -radius, 0);
+      const startB = await nodeOffsetToPage(page, node, radius, 0);
+      const cos = Math.cos(radians);
+      const sin = Math.sin(radians);
+      const endA = await nodeOffsetToPage(page, node, -radius * cos, -radius * sin);
+      const endB = await nodeOffsetToPage(page, node, radius * cos, 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)}`
+        );
+      const box = node.frame ?? {
+        x: node.absolutePosition.x,
+        y: node.absolutePosition.y,
+        width: node.layout.width,
+        height: node.layout.height
+      };
+      return writeSootsimScreenshot(name, {
+        crop: {
+          x: box.x,
+          y: box.y,
+          w: box.width,
+          h: box.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 createSootSimElement({ ...matcher, index });
+    }
+  };
+  return el;
+}
+function element(matcher) {
+  return createSootSimElement(matcher);
+}
+var device = {
+  _currentUrl: "",
+  _platform: DETOX_PLATFORM,
+  async launchApp(opts) {
+    if (!_browser) {
+      const launched = await launchReapedChromeScoped(
+        (options) => import_playwright.chromium.launch(options),
+        { headless: true }
+      );
+      _browser = launched.browser;
+      _reapBrowserNow = launched.reapNow;
+    }
+    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);
+    await waitForSootsimSurfaceMetrics(_page, 3e4);
+    await waitForSootsimShellReady(_page, 3e4);
+    await waitForSootsimWorkletsIdle(_page, 3e3);
+    device._lastReadyAtMs = Date.now();
+  },
+  _lastReadyAtMs: 0,
+  async reloadReactNative() {
+    const page = getPage();
+    await page.reload({ waitUntil: "load", timeout: 3e4 });
+    await waitForSootsimTree(page, 3e4);
+    await waitForSootsimSurfaceMetrics(page, 3e4);
+    await waitForSootsimShellReady(page, 3e4);
+    await waitForSootsimWorkletsIdle(page, 3e3);
+  },
+  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);
+    await waitForSootsimSurfaceMetrics(page, 1e4);
+    await waitForSootsimShellReady(page, 1e4);
+    await waitForSootsimWorkletsIdle(page, 3e3);
+  },
+  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 `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 `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("rnx 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 });
+  },
+  // park every render clock before the interaction, detect the first changed
+  // stepped frame inside the named component, then advance exact 60fps frames
+  // to each requested offset. native extraction also chooses the first frame
+  // at or after an offset, so both sides use the same rounding convention.
+  async takeScreenshotStagesFromVisibleChangeFast(namePrefix, stages, options) {
+    const page = getPage();
+    const token = `motion-${process.pid}-${Date.now()}-${Math.random()}`;
+    await page.evaluate(import_motion_change.measureMotionChange, {
+      definition: import_motion_change.MOTION_CHANGE_DEFINITION,
+      installGlobal: true
+    });
+    const capturePromise = page.evaluate(
+      async (input) => {
+        const captureWindow = window;
+        const live = captureWindow.SootSim?.bridges?.liveComposite;
+        const lockstep = captureWindow.SootSim?.bridges?.lockstepCapture;
+        if (!live || typeof live.captureFresh !== "function") {
+          throw new Error("rnx live composite bridge is not installed");
+        }
+        if (!lockstep || typeof lockstep.begin !== "function") {
+          throw new Error("SootSim lockstep capture bridge is not installed");
+        }
+        const registry = captureWindow.__sootsimVisibleChangeCaptures ?? (captureWindow.__sootsimVisibleChangeCaptures = {});
+        const state = {
+          cancelled: false,
+          ready: false,
+          triggerCompleted: false
+        };
+        registry[input.token] = state;
+        const measureChange = captureWindow.__sootsimMeasureMotionChange;
+        if (!measureChange) {
+          throw new Error("rnx motion change definition is not installed");
+        }
+        const captureBitmap = async () => {
+          const { canvas } = await live.captureFresh();
+          if (!canvas) throw new Error("rnx live composite produced no canvas");
+          return createImageBitmap(canvas);
+        };
+        const boundsFor = (bitmap) => {
+          const scale = input.rootFrame && input.rootFrame.width > 0 ? bitmap.width / input.rootFrame.width : 1;
+          return {
+            height: input.frame ? Math.max(
+              1,
+              Math.min(
+                bitmap.height,
+                Math.ceil((input.frame.y + input.frame.height) * scale)
+              ) - Math.max(0, Math.floor(input.frame.y * scale))
+            ) : bitmap.height,
+            left: input.frame ? Math.max(0, Math.floor(input.frame.x * scale)) : 0,
+            top: input.frame ? Math.max(0, Math.floor(input.frame.y * scale)) : 0,
+            width: input.frame ? Math.max(
+              1,
+              Math.min(
+                bitmap.width,
+                Math.ceil((input.frame.x + input.frame.width) * scale)
+              ) - Math.max(0, Math.floor(input.frame.x * scale))
+            ) : bitmap.width
+          };
+        };
+        const regionPixels = (bitmap) => {
+          const bounds = boundsFor(bitmap);
+          const canvas = document.createElement("canvas");
+          canvas.width = bounds.width;
+          canvas.height = bounds.height;
+          const context = canvas.getContext("2d", { willReadFrequently: true });
+          if (!context) throw new Error("rnx motion detector needs a 2d canvas");
+          context.drawImage(
+            bitmap,
+            bounds.left,
+            bounds.top,
+            bounds.width,
+            bounds.height,
+            0,
+            0,
+            bounds.width,
+            bounds.height
+          );
+          return context.getImageData(0, 0, bounds.width, bounds.height).data;
+        };
+        const encode = (snapshot) => {
+          const canvas = document.createElement("canvas");
+          canvas.width = snapshot.bitmap.width;
+          canvas.height = snapshot.bitmap.height;
+          const context = canvas.getContext("2d");
+          if (!context) throw new Error("rnx motion capture needs a 2d canvas");
+          context.drawImage(snapshot.bitmap, 0, 0);
+          snapshot.bitmap.close();
+          return {
+            actualMs: snapshot.actualMs,
+            dataUrl: canvas.toDataURL("image/png"),
+            label: snapshot.label,
+            offsetMs: snapshot.offsetMs,
+            frameIndex: snapshot.frameIndex,
+            virtualTimestampMs: snapshot.virtualTimestampMs
+          };
+        };
+        const controller = await lockstep.begin(60);
+        try {
+          const baselineBitmap = await captureBitmap();
+          const baseline = regionPixels(baselineBitmap);
+          baselineBitmap.close();
+          state.ready = true;
+          while (!state.triggerCompleted) {
+            if (state.cancelled) throw new Error("rnx motion capture was cancelled");
+            await new Promise((resolve) => setTimeout(resolve, 0));
+          }
+          let visibleStart = null;
+          let detectedMeasurement = null;
+          const detectionFrameLimit = Math.ceil(input.detectionTimeoutMs * 60 / 1e3);
+          for (let frame = 0; frame < detectionFrameLimit; frame++) {
+            if (state.cancelled) throw new Error("rnx motion capture was cancelled");
+            const receipt = await controller.stepFrame();
+            const candidateBitmap = await captureBitmap();
+            const bounds = boundsFor(candidateBitmap);
+            const measurement = measureChange({
+              baseline,
+              candidate: regionPixels(candidateBitmap),
+              definition: input.motionChangeDefinition,
+              height: bounds.height,
+              label: "SootSim visible-change detector",
+              width: bounds.width
+            });
+            candidateBitmap.close();
+            if (measurement.passedMinimum) {
+              visibleStart = receipt;
+              detectedMeasurement = measurement;
+              break;
+            }
+          }
+          if (!visibleStart || !detectedMeasurement) {
+            throw new Error(
+              `rnx motion had no visible change before ${input.detectionTimeoutMs}ms`
+            );
+          }
+          const snapshots = [];
+          for (const stage of input.stages) {
+            if (state.cancelled) throw new Error("rnx motion capture was cancelled");
+            const receipt = await controller.stepToOffset(visibleStart, stage.offsetMs);
+            snapshots.push({
+              actualMs: receipt.virtualTimestampMs - visibleStart.virtualTimestampMs,
+              bitmap: await captureBitmap(),
+              frameIndex: receipt.frameIndex,
+              label: stage.label,
+              offsetMs: stage.offsetMs,
+              virtualTimestampMs: receipt.virtualTimestampMs
+            });
+          }
+          return {
+            frames: snapshots.map(encode),
+            visibleChangeDetection: {
+              actualMs: visibleStart.frameIndex * 1e3 / 60,
+              changedPixelPercent: detectedMeasurement.changePercent,
+              changedPixels: detectedMeasurement.changePixels,
+              channelThreshold: input.motionChangeDefinition.channelThreshold,
+              minimumChangePercent: input.motionChangeDefinition.minimumChangePercent,
+              totalPixels: detectedMeasurement.totalPixels,
+              frameIndex: visibleStart.frameIndex,
+              virtualTimestampMs: visibleStart.virtualTimestampMs
+            }
+          };
+        } finally {
+          controller.end();
+          delete registry[input.token];
+        }
+      },
+      {
+        detectionTimeoutMs: options.detectionTimeoutMs ?? 3e3,
+        frame: options.frame ?? null,
+        motionChangeDefinition: import_motion_change.MOTION_CHANGE_DEFINITION,
+        rootFrame: options.rootFrame ?? null,
+        stages,
+        token
+      }
+    );
+    await page.waitForFunction(
+      (captureToken) => {
+        const registry = window.__sootsimVisibleChangeCaptures;
+        return registry?.[captureToken]?.ready === true;
+      },
+      token,
+      { timeout: 5e3 }
+    );
+    const triggerStartMs = Date.now();
+    let triggerCompletedMs = 0;
+    try {
+      await Promise.resolve(options.trigger());
+      triggerCompletedMs = Date.now();
+      await page.evaluate((captureToken) => {
+        const registry = window.__sootsimVisibleChangeCaptures;
+        const capture2 = registry?.[captureToken];
+        if (!capture2) throw new Error("rnx motion capture disarmed before trigger");
+        capture2.triggerCompleted = true;
+      }, token);
+      const capture = await capturePromise;
+      return {
+        frames: writeFastScreenshotFrames(namePrefix, capture.frames),
+        triggerCompletedMs,
+        triggerStartMs,
+        visibleChangeDetection: {
+          ...capture.visibleChangeDetection,
+          frame: options.frame ?? null,
+          rootFrame: options.rootFrame ?? null
+        }
+      };
+    } catch (error) {
+      await page.evaluate((captureToken) => {
+        const registry = window.__sootsimVisibleChangeCaptures;
+        const capture = registry?.[captureToken];
+        if (capture) capture.cancelled = true;
+      }, token).catch(() => {
+      });
+      await capturePromise.catch(() => {
+      });
+      throw error;
+    }
+  },
+  // 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, options) {
+    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("rnx screenshot bridge is not installed");
+        }
+        if (!input.skipWarmup) {
+          await screenshot({ format: "png" });
+        }
+        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({ format: "png" });
+                  }
+                  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, skipWarmup: options?.skipWarmup === true }
+    );
+    return writeFastScreenshotFrames(namePrefix, frames);
+  },
+  // 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({ format: "png" });
+          out.push({ label: stage.label, offsetMs: stage.offsetMs, actualMs, dataUrl });
+        }
+        return out;
+      },
+      { stages }
+    );
+    return writeFastScreenshotFrames(namePrefix, frames);
+  },
+  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;
+    const page = getPage();
+    const dispatched = await page.evaluate(async () => {
+      const goBack = window.SootSim?.bridges?.mainShell?.goBack;
+      if (typeof goBack !== "function") return false;
+      return await goBack() !== false;
+    });
+    if (!dispatched) throw new Error("sootsim Android back bridge is not installed");
+    if (_synchronizationEnabled) {
+      await waitForSootsimIdle(page);
+    }
+  },
+  // 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 sootsimExpect = createExpect(findNodeByMatcher, getPage);
+var sootsimWaitFor = createWaitFor(findNodeByMatcher, getPage);
+async function cleanup() {
+  await closeBrowser();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  by,
+  cleanup,
+  device,
+  element,
+  expect,
+  waitFor,
+  waitForSootsimIdle
+});