peachsim 0.1.527

package/dist-lib/detox/index.cjs

@@ -0,0 +1,3789 @@
+/*! rnx v0.1.527 | (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/attempt-events.cjs
+var require_attempt_events = __commonJS({
+  "detox/attempt-events.cjs"(exports2, module2) {
+    "use strict";
+    var fs2 = require("node:fs");
+    var path2 = require("node:path");
+    function attemptEventsPath() {
+      const enabled = process.env.CONFORMANCE_PROOF === "1" || Boolean(process.env.CONFORMANCE_PROOF_DIR);
+      if (!enabled) return null;
+      const root = path2.resolve(
+        process.cwd(),
+        process.env.CONFORMANCE_PROOF_DIR || "artifacts/conformance-proof/latest"
+      );
+      return path2.join(root, "events.jsonl");
+    }
+    function writeAttemptEvent2(event) {
+      const output = attemptEventsPath();
+      if (output === null) return false;
+      fs2.mkdirSync(path2.dirname(output), { recursive: true });
+      fs2.appendFileSync(output, `${JSON.stringify(event)}
+`);
+      return true;
+    }
+    module2.exports = { attemptEventsPath, writeAttemptEvent: writeAttemptEvent2 };
+  }
+});
+
+// detox/proof-frame.cjs
+var require_proof_frame = __commonJS({
+  "detox/proof-frame.cjs"(exports2, module2) {
+    "use strict";
+    var PROOF_CONTENT_DEFINITION = Object.freeze({
+      channelThreshold: 24,
+      contentBandInsetFraction: 0.08,
+      minimumContentPercent: 5e-3
+    });
+    var REQUIRED_IDENTICAL_PROOF_FRAMES2 = 3;
+    var REQUIRED_IDENTICAL_FLOW_FRAMES = 1;
+    function framesIdentical2(a, b) {
+      if (!a || !b || a.length !== b.length) return false;
+      return a.equals(b);
+    }
+    function measureProofFrameContent(input) {
+      if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("proof content measurement requires an input object");
+      }
+      const { data, width, height } = input;
+      if (!data || typeof data.length !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0 || data.length !== width * height * 4) {
+        throw new Error("proof content measurement needs RGBA pixels and dimensions");
+      }
+      const yStart = Math.floor(height * PROOF_CONTENT_DEFINITION.contentBandInsetFraction);
+      const yEnd = Math.ceil(height * (1 - PROOF_CONTENT_DEFINITION.contentBandInsetFraction));
+      const bucketCounts = new Uint32Array(32 * 32 * 32);
+      let totalPixels = 0;
+      for (let y = yStart; y < yEnd; y++) {
+        for (let x = 0; x < width; x++) {
+          const offset = (y * width + x) * 4;
+          const bucket = data[offset] >> 3 << 10 | data[offset + 1] >> 3 << 5 | data[offset + 2] >> 3;
+          bucketCounts[bucket]++;
+          totalPixels++;
+        }
+      }
+      let dominantBucket = 0;
+      for (let index = 1; index < bucketCounts.length; index++) {
+        if (bucketCounts[index] > bucketCounts[dominantBucket]) dominantBucket = index;
+      }
+      const dominant = {
+        red: ((dominantBucket >> 10 & 31) << 3) + 4,
+        green: ((dominantBucket >> 5 & 31) << 3) + 4,
+        blue: ((dominantBucket & 31) << 3) + 4
+      };
+      let contentPixels = 0;
+      for (let y = yStart; y < yEnd; y++) {
+        for (let x = 0; x < width; x++) {
+          const offset = (y * width + x) * 4;
+          if (Math.max(
+            Math.abs(data[offset] - dominant.red),
+            Math.abs(data[offset + 1] - dominant.green),
+            Math.abs(data[offset + 2] - dominant.blue)
+          ) >= PROOF_CONTENT_DEFINITION.channelThreshold) {
+            contentPixels++;
+          }
+        }
+      }
+      const contentPercent = contentPixels / totalPixels * 100;
+      return {
+        contentPercent,
+        contentPixels,
+        dominant,
+        passedMinimum: contentPercent >= PROOF_CONTENT_DEFINITION.minimumContentPercent,
+        totalPixels
+      };
+    }
+    function settleDecision(previousPixels, currentFrame) {
+      if (!currentFrame) return { decision: "continue", content: null };
+      const content = measureProofFrameContent(currentFrame);
+      if (!content.passedMinimum) {
+        return { decision: "insufficient-content", content };
+      }
+      if (previousPixels && framesIdentical2(previousPixels, currentFrame.data)) {
+        return { decision: "identical", content };
+      }
+      return { decision: "changed", content };
+    }
+    module2.exports = {
+      PROOF_CONTENT_DEFINITION,
+      REQUIRED_IDENTICAL_PROOF_FRAMES: REQUIRED_IDENTICAL_PROOF_FRAMES2,
+      REQUIRED_IDENTICAL_FLOW_FRAMES,
+      framesIdentical: framesIdentical2,
+      measureProofFrameContent,
+      settleDecision
+    };
+  }
+});
+
+// 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 discoveredChromeProcesses = /* @__PURE__ */ new WeakMap();
+var reapPids = /* @__PURE__ */ new Map();
+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 processIdentity(pid) {
+  try {
+    const identity = (0, import_node_child_process.execFileSync)(
+      "/bin/ps",
+      ["-p", String(pid), "-o", "lstart=", "-o", "command="],
+      { encoding: "utf8" }
+    ).trim();
+    return identity || null;
+  } catch {
+    return null;
+  }
+}
+function softwareChromeAllowed(runtime = currentRuntime()) {
+  if (runtime.platform !== "linux") return false;
+  return runtime.env.GITHUB_ACTIONS === "true" && runtime.env.RUNNER_OS === "Linux" || runtime.env.CONTRAST_CF_FACTORY_CONTAINER === "1";
+}
+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`
+    );
+  }
+  for (const name of ["--enable-features=", "--disable-features="]) {
+    const lists = args.filter((arg) => arg.startsWith(name)).map((arg) => arg.slice(name.length).split(",").filter(Boolean));
+    const kept = new Set(lists.at(-1) ?? []);
+    const dropped = lists.slice(0, -1).flat().filter((feature) => !kept.has(feature));
+    if (dropped.length > 0) {
+      throw new Error(
+        `[reap-browser] Chrome keeps only its last ${name.slice(0, -1)} switch, which dropped ${dropped.join(",")}; add them to the merged list in scripts/lib/reap-browser.ts`
+      );
+    }
+  }
+  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 killOwnedTree(tracked) {
+  if (tracked.readIdentity(tracked.pid) !== tracked.identity) return;
+  killTree(tracked.pid);
+}
+function trackReapPid(pid, readIdentity = processIdentity) {
+  const identity = readIdentity(pid);
+  if (identity === null) return null;
+  const current = reapPids.get(pid);
+  if (current?.identity === identity && current.readIdentity === readIdentity) {
+    return current;
+  }
+  const tracked = { pid, identity, readIdentity };
+  reapPids.set(pid, tracked);
+  installReaper();
+  return tracked;
+}
+function untrackReapPid(tracked) {
+  if (reapPids.get(tracked.pid) === tracked) reapPids.delete(tracked.pid);
+}
+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, readIdentity = processIdentity) {
+  if (browser && typeof browser === "object") discoveredChromePids.set(browser, pid);
+  discoveredChromePids.set(control, pid);
+  const tracked = trackReapPid(pid, readIdentity);
+  if (tracked === null) return;
+  if (browser && typeof browser === "object") {
+    discoveredChromeProcesses.set(browser, tracked);
+  }
+  discoveredChromeProcesses.set(control, tracked);
+}
+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 tracked = browser && typeof browser === "object" ? discoveredChromeProcesses.get(browser) : void 0;
+  if (tracked) {
+    killOwnedTree(tracked);
+    untrackReapPid(tracked);
+    return;
+  }
+  const candidate = browser;
+  if (candidate && typeof candidate.close === "function") {
+    try {
+      await candidate.close();
+    } catch {
+    }
+  }
+}
+async function validateLaunchedGpuBrowser(browser, runtime, rendererTarget, commandForPid = processCommand, readIdentity = processIdentity) {
+  if (softwareChromeAllowed(runtime)) return;
+  const root = rootChromePid(browser);
+  const launchedControl = browserControl(browser);
+  if (root !== null && launchedControl) {
+    registerChromePid(browser, launchedControl, root, readIdentity);
+  }
+  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, readIdentity);
+      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 tracked of reapPids.values()) killOwnedTree(tracked);
+  };
+  if (!signalShutdownClaimed) {
+    process.on("SIGTERM", () => {
+      reap();
+      process.exit(0);
+    });
+    process.on("SIGINT", () => {
+      reap();
+      process.exit(0);
+    });
+  }
+  process.on("exit", reap);
+}
+async function launchReapedScoped(launch, readIdentity = processIdentity) {
+  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) {
+    const tracked = trackReapPid(root, readIdentity);
+    if (tracked !== null) mine.add(tracked);
+  }
+  const evented = browserControl(browser) ?? browser;
+  if (typeof evented.on === "function") {
+    const disconnectEvent = typeof evented.newBrowserCDPSession === "function" ? "disconnected" : "close";
+    evented.on(disconnectEvent, () => {
+      for (const tracked of mine) {
+        killOwnedTree(tracked);
+        untrackReapPid(tracked);
+      }
+      mine.clear();
+    });
+  }
+  const reapNow = () => {
+    for (const tracked of mine) {
+      killOwnedTree(tracked);
+      untrackReapPid(tracked);
+    }
+    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"
+  ];
+}
+var PLAYWRIGHT_DISABLED_FEATURES = [
+  "AvoidUnnecessaryBeforeUnloadCheckSync",
+  "BlockOriginHeaderModificationOnRedirect",
+  "BoundaryEventDispatchTracksNodeRemoval",
+  "DestroyProfileOnBrowserClose",
+  "DialMediaRouteProvider",
+  "GlobalMediaControls",
+  "HttpsUpgrades",
+  "LensOverlay",
+  "MediaRouter",
+  "PaintHolding",
+  "ThirdPartyStoragePartitioning",
+  "Translate",
+  "AutoDeElevate",
+  "RenderDocument",
+  "OptimizationHints",
+  "msForceBrowserSignIn",
+  "msEdgeUpdateLaunchServicesPreferredVersion"
+];
+var PLAYWRIGHT_ENABLED_FEATURES = ["CDPScreenshotNewSurface"];
+var DISABLED_FEATURES = ["NetworkTimeServiceQuerying"];
+function mergeFeatureSwitches(args, enabled = []) {
+  const enable = /* @__PURE__ */ new Set([...PLAYWRIGHT_ENABLED_FEATURES, ...enabled]);
+  const disable = /* @__PURE__ */ new Set([...PLAYWRIGHT_DISABLED_FEATURES, ...DISABLED_FEATURES]);
+  const rest = [];
+  for (const arg of args) {
+    const match = /^--(enable|disable)-features=(.*)$/.exec(arg);
+    if (!match) {
+      rest.push(arg);
+      continue;
+    }
+    for (const feature of match[2].split(",")) {
+      if (feature) (match[1] === "enable" ? enable : disable).add(feature);
+    }
+  }
+  return [
+    ...rest,
+    `--enable-features=${[...enable].join(",")}`,
+    `--disable-features=${[...disable].join(",")}`
+  ];
+}
+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: mergeFeatureSwitches([
+      ...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,
+        policy.processIdentity
+      );
+    } 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" && arg !== "--disable-gpu-watchdog" && arg !== "--enable-skia-graphite" && !/^--enable-unsafe-webgpu(?:=.*)?$/i.test(arg) && !/^--enable-unsafe-swiftshader(?:=.*)?$/i.test(arg);
+  });
+  const software = {
+    ...opts,
+    // playwright's bundled software chromium exposes no navigator.gpu without
+    // --enable-unsafe-webgpu plus the Vulkan feature, 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.
+    args: mergeFeatureSwitches(
+      [
+        ...unmanagedCallerArgs,
+        "--use-angle=swiftshader",
+        "--enable-unsafe-swiftshader",
+        "--enable-unsafe-webgpu",
+        // without Skia Graphite as chromium's own compositor, SwiftShader has no
+        // shared-image backing for a WebGPU canvas swap chain at any size: the
+        // first configured canvas fails "Could not find SharedImageBackingFactory"
+        // and chromium destroys the device mid-capture. compute-only WebGPU
+        // still works, so an adapter probe cannot see this.
+        "--enable-skia-graphite",
+        // the GPU watchdog kills the GPU process when a task outlives its
+        // timeout, and SwiftShader precompiling Graphite pipelines on two CPU
+        // cores can legitimately outlive it. the cost: a genuinely wedged GPU
+        // process now holds its job until the job's own timeout instead of
+        // dying fast.
+        "--disable-gpu-watchdog"
+      ],
+      ["Vulkan"]
+    )
+  };
+  delete software.channel;
+  delete software.executablePath;
+  return software;
+}
+function chromeLaunchOptions(opts = {}, runtime = currentRuntime()) {
+  if (signalShutdownClaimed) {
+    opts = { ...opts, handleSIGINT: false, handleSIGTERM: false, handleSIGHUP: false };
+  }
+  return softwareChromeAllowed(runtime) ? softwareChromeLaunchOptions(opts) : gpuChromeLaunchOptions(opts, runtime);
+}
+async function launchReapedChromeScoped(launch, opts = {}, rendererTarget, policy = {}) {
+  return launchReapedScoped(
+    platformChromeLaunch(launch, opts, rendererTarget, policy),
+    policy.processIdentity
+  );
+}
+
+// ../sootsim-engine/src/capture/browser-composite.ts
+function resolveBrowserCompositeCdpClip(request, metrics) {
+  if (!metrics || typeof metrics !== "object") {
+    throw new Error("browser composite capture requires CDP layout metrics");
+  }
+  const physical = Reflect.get(metrics, "layoutViewport");
+  const css = Reflect.get(metrics, "cssLayoutViewport");
+  if (!physical || typeof physical !== "object" || !css || typeof css !== "object") {
+    throw new Error("browser composite capture requires physical and CSS viewports");
+  }
+  const physicalWidth = Reflect.get(physical, "clientWidth");
+  const cssWidth = Reflect.get(css, "clientWidth");
+  if (typeof physicalWidth !== "number" || !Number.isFinite(physicalWidth) || physicalWidth <= 0 || typeof cssWidth !== "number" || !Number.isFinite(cssWidth) || cssWidth <= 0) {
+    throw new Error("browser composite capture requires positive viewport widths");
+  }
+  const devicePixelRatio = physicalWidth / cssWidth;
+  const padding = 1;
+  return {
+    x: request.rect.x - padding,
+    y: request.rect.y - padding,
+    width: request.rect.width + padding * 2,
+    height: request.rect.height + padding * 2,
+    scale: request.outputWidth / request.rect.width / devicePixelRatio
+  };
+}
+function readBrowserCompositeCaptureRequest(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("browser composite capture request must be an object");
+  }
+  const rect = Reflect.get(value, "rect");
+  if (!rect || typeof rect !== "object") {
+    throw new Error("browser composite capture request requires a rect");
+  }
+  const request = {
+    rect: {
+      x: Reflect.get(rect, "x"),
+      y: Reflect.get(rect, "y"),
+      width: Reflect.get(rect, "width"),
+      height: Reflect.get(rect, "height")
+    },
+    outputWidth: Reflect.get(value, "outputWidth"),
+    outputHeight: Reflect.get(value, "outputHeight")
+  };
+  const positions = [request.rect.x, request.rect.y];
+  const dimensions = [
+    request.rect.width,
+    request.rect.height,
+    request.outputWidth,
+    request.outputHeight
+  ];
+  if (positions.some((number) => typeof number !== "number" || !Number.isFinite(number))) {
+    throw new Error("browser composite capture request positions must be finite");
+  }
+  if (dimensions.some(
+    (number) => typeof number !== "number" || !Number.isFinite(number) || number <= 0
+  ) || !Number.isInteger(request.outputWidth) || !Number.isInteger(request.outputHeight)) {
+    throw new Error("browser composite capture request dimensions must be positive");
+  }
+  const scaleX = request.outputWidth / request.rect.width;
+  const scaleY = request.outputHeight / request.rect.height;
+  if (Math.abs(scaleX - scaleY) > 1e-3) {
+    throw new Error("browser composite capture output scale must be uniform");
+  }
+  return request;
+}
+
+// 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;
+  let lastRead = null;
+  const describeLastRead = () => {
+    if (lastRead === null) {
+      if (lastError === void 0) return "no read settled";
+      const message = lastError instanceof Error ? lastError.message : String(lastError);
+      return `last read failed: ${message}`;
+    }
+    let serialized;
+    try {
+      const seen = /* @__PURE__ */ new WeakSet();
+      serialized = JSON.stringify(lastRead.value, (_key, entry) => {
+        if (typeof entry !== "object" || entry === null) return entry;
+        if (seen.has(entry)) return "[circular]";
+        seen.add(entry);
+        return entry;
+      }) ?? String(lastRead.value);
+    } catch {
+      return "last value (unserializable)";
+    }
+    if (serialized.length <= 300) return `last value ${serialized}`;
+    return `last value ${serialized.slice(0, 300)}... (${serialized.length} chars)`;
+  };
+  const timeoutError = () => new Error(
+    `${options.label} timed out after ${options.timeoutMs}ms; ${describeLastRead()}`,
+    { 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 {
+        lastRead = { value: outcome.value };
+        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
+function resolveScrollStartPosition(value, label) {
+  const normalized = value === void 0 || Number.isNaN(value) ? 0.5 : value;
+  if (!Number.isFinite(normalized) || normalized < 0 || normalized > 1) {
+    throw new Error(`${label} must be between 0 and 1`);
+  }
+  return normalized;
+}
+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, startPositionX, startPositionY) {
+  const normalizedStartX = resolveScrollStartPosition(
+    startPositionX,
+    "scroll startPositionX"
+  );
+  const normalizedStartY = resolveScrollStartPosition(
+    startPositionY,
+    "scroll startPositionY"
+  );
+  const startSootSimX = node.absolutePosition.x + node.layout.width * normalizedStartX;
+  const startSootSimY = node.absolutePosition.y + node.layout.height * normalizedStartY;
+  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, startPositionX, startPositionY) {
+  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, startPositionX, startPositionY);
+  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 || typeof frame?.area !== "number") return 0;
+  return frame.area / 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;
+    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;
+      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,
+        startPositionX,
+        startPositionY
+      );
+      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);
+
+// detox/navigation-lifecycle.ts
+var import_attempt_events = __toESM(require_attempt_events(), 1);
+var DIAGNOSTIC_LIMIT = 40;
+var pageDiagnostics = /* @__PURE__ */ new WeakMap();
+var activeNavigations = /* @__PURE__ */ new WeakMap();
+var lastNavigations = /* @__PURE__ */ new WeakMap();
+var nextNavigationIdentity = 0;
+function recordPageDiagnostic(page, diagnostic, persist = false) {
+  const entries = pageDiagnostics.get(page);
+  if (!entries) return;
+  entries.push(diagnostic);
+  if (entries.length > DIAGNOSTIC_LIMIT) entries.shift();
+  if (persist) (0, import_attempt_events.writeAttemptEvent)(diagnostic);
+}
+function isTopLevelDocumentRequest(page, request) {
+  return request.isNavigationRequest() && request.resourceType() === "document" && request.frame() === page.mainFrame();
+}
+function recordNavigationMilestoneFor(page, active, milestone, details = {}) {
+  recordPageDiagnostic(
+    page,
+    {
+      ...active,
+      ...details,
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      milestone,
+      target: process.env.CONFORMANCE_PROOF_TARGET || "sootsim",
+      type: "rnx-navigation",
+      url: details.url ?? active.navigationUrl
+    },
+    true
+  );
+}
+function recordNavigationMilestone(page, milestone, details = {}) {
+  const active = activeNavigations.get(page);
+  if (active) recordNavigationMilestoneFor(page, active, milestone, details);
+}
+function attachPageDiagnostics(page) {
+  if (pageDiagnostics.has(page)) return;
+  pageDiagnostics.set(page, []);
+  page.on("console", (message) => {
+    recordPageDiagnostic(page, {
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      level: message.type(),
+      message: message.text(),
+      type: "page-console"
+    });
+  });
+  page.on("pageerror", (error) => {
+    recordPageDiagnostic(page, {
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      message: error.message,
+      type: "page-error"
+    });
+  });
+  page.on("request", (request) => {
+    if (!isTopLevelDocumentRequest(page, request)) return;
+    recordNavigationMilestone(page, "document-request", {
+      method: request.method(),
+      url: request.url()
+    });
+  });
+  page.on("response", (response) => {
+    const request = response.request();
+    if (!isTopLevelDocumentRequest(page, request)) return;
+    recordNavigationMilestone(page, "document-response", {
+      headersReceived: true,
+      status: response.status(),
+      url: request.url()
+    });
+  });
+  page.on("requestfinished", (request) => {
+    if (!isTopLevelDocumentRequest(page, request)) return;
+    recordNavigationMilestone(page, "document-request-finished", { url: request.url() });
+  });
+  page.on("requestfailed", (request) => {
+    const failure = request.failure();
+    const errorText = failure?.errorText ?? "";
+    if (isTopLevelDocumentRequest(page, request)) {
+      recordNavigationMilestone(page, "document-request-failed", {
+        errorText,
+        url: request.url()
+      });
+      return;
+    }
+    recordPageDiagnostic(page, {
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      errorText,
+      method: request.method(),
+      type: "subresource-request-failed",
+      url: request.url()
+    });
+  });
+  page.on("domcontentloaded", () => {
+    recordNavigationMilestone(page, "domcontentloaded");
+  });
+  page.on("load", () => {
+    recordNavigationMilestone(page, "load");
+  });
+}
+async function readSootsimPageState(page) {
+  try {
+    return await page.evaluate(() => ({
+      bodyText: document.body?.innerText?.slice(0, 500) ?? "",
+      bridges: {
+        sootsim: Boolean(window.SootSim),
+        test: Boolean(window.__sootsimTest)
+      },
+      globals: Object.keys(window).filter((key) => key.startsWith("__sootsim") || key === "SootSim").sort(),
+      readyState: document.readyState,
+      title: document.title,
+      url: window.location.href
+    }));
+  } catch (error) {
+    return {
+      evaluateError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function describeSootsimBridgeFailure(page, cause, summary = "timed out waiting for sootsim test bridge", pageState) {
+  const recordBridgeFailure = pageState === void 0;
+  const state = pageState ?? await readSootsimPageState(page);
+  const navigation = lastNavigations.get(page);
+  if (recordBridgeFailure && navigation) {
+    recordNavigationMilestoneFor(page, navigation, "error", {
+      errorText: cause instanceof Error ? cause.message : String(cause),
+      failurePhase: "bridge",
+      pageState: state
+    });
+  }
+  return new Error(
+    [
+      summary,
+      `cause: ${cause instanceof Error ? cause.message : String(cause)}`,
+      `page: ${JSON.stringify(state)}`,
+      `recent page diagnostics:
+${JSON.stringify(getSootsimNavigationDiagnostics(page))}`
+    ].join("\n")
+  );
+}
+async function navigateSootsimPage(page, url, identity) {
+  attachPageDiagnostics(page);
+  const navigation = {
+    ...identity,
+    navigationUrl: url,
+    navigationId: ++nextNavigationIdentity
+  };
+  activeNavigations.set(page, navigation);
+  lastNavigations.set(page, navigation);
+  recordNavigationMilestone(page, "start");
+  try {
+    return await page.goto(url, { waitUntil: "load", timeout: 3e4 });
+  } catch (error) {
+    const pageState = await readSootsimPageState(page);
+    recordNavigationMilestone(page, "error", {
+      errorText: error instanceof Error ? error.message : String(error),
+      failurePhase: "navigation",
+      pageState
+    });
+    throw await describeSootsimBridgeFailure(
+      page,
+      error,
+      "sootsim navigation failed",
+      pageState
+    );
+  } finally {
+    activeNavigations.delete(page);
+  }
+}
+function getSootsimNavigationDiagnostics(page) {
+  return [...pageDiagnostics.get(page) ?? []];
+}
+
+// detox/index.ts
+var import_proof_frame = __toESM(require_proof_frame(), 1);
+var BASE_URL = process.env.RNX_URL || "http://localhost:5173";
+var SCREENSHOT_DIR = process.env.RNX_SCREENSHOT_DIR || path.join(process.cwd(), "test", "detox-driver", "screenshots");
+var DETOX_PLATFORM = process.env.RNX_PLATFORM === "android" ? "android" : "ios";
+var _browser = null;
+var _reapBrowserNow = null;
+var _context = null;
+var _page = null;
+var _synchronizationEnabled = false;
+var _suspendedAppId = null;
+var _browserCompromised = null;
+var browserIdentity = 0;
+var contextIdentity = 0;
+var nextBrowserIdentity = 0;
+var nextContextIdentity = 0;
+var BROWSER_LIFECYCLE_TIMEOUT_MS = 3e4;
+async function withLifecycleTimeout(actionName, targetContextId, fn, timeoutMs = BROWSER_LIFECYCLE_TIMEOUT_MS) {
+  const start = Date.now();
+  let timer;
+  try {
+    return await Promise.race([
+      fn(),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          const elapsed = Date.now() - start;
+          reject(
+            new Error(
+              `sootsim browser lifecycle error: ${actionName} did not settle after ${elapsed}ms (context=${targetContextId})`
+            )
+          );
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var STATUS_BAR_OVERRIDE_EVENT = "sootsim:statusBarOverride";
+function getPage() {
+  if (_browserCompromised) {
+    throw new Error(`sootsim browser is compromised: ${_browserCompromised}`);
+  }
+  if (!_page)
+    throw new Error("sootsim driver not initialized -- call device.launchApp() first");
+  return _page;
+}
+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"})`
+    );
+  }
+}
+function reapOwnedBrowser() {
+  const reap = _reapBrowserNow;
+  _reapBrowserNow = null;
+  _browser = null;
+  try {
+    reap?.();
+  } catch {
+  }
+}
+async function closeContext() {
+  if (_browserCompromised) {
+    throw new Error(`sootsim browser is compromised: ${_browserCompromised}`);
+  }
+  if (!_context) return;
+  const context = _context;
+  const closingContextId = contextIdentity;
+  try {
+    await withLifecycleTimeout("context.close()", closingContextId, () => context.close());
+    _context = null;
+    _page = null;
+    contextIdentity = 0;
+    _synchronizationEnabled = false;
+  } catch (error) {
+    _browserCompromised = error instanceof Error ? error.message : String(error);
+    reapOwnedBrowser();
+    throw error;
+  }
+}
+async function closeBrowser() {
+  if (!_browser) return;
+  const browser = _browser;
+  const reapBrowserNow = _reapBrowserNow;
+  _browser = null;
+  _reapBrowserNow = null;
+  browserIdentity = 0;
+  let closeError = null;
+  try {
+    await closeContext();
+  } catch (error) {
+    closeError = error instanceof Error ? error : new Error(String(error));
+  }
+  try {
+    reapBrowserNow?.();
+  } catch {
+  }
+  try {
+    await browser.close();
+  } catch {
+  }
+  if (closeError) {
+    throw closeError;
+  }
+}
+async function waitForSootsimIdle(page, maxMs = 3e3, strict = false) {
+  const result = await page.evaluate(
+    async ({ maxMs: maxMs2, strict: strict2 }) => {
+      const start = Date.now();
+      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?.timedOut) {
+            return {
+              settled: false,
+              elapsed: transitionResult.waitedMs,
+              reason: "screen transition"
+            };
+          }
+        }
+      } catch (error) {
+        transitionError = error instanceof Error ? error.message : String(error);
+      }
+      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 = [];
+        let animating = false;
+        let auxSurfaceDebug = null;
+        let layoutDirty = false;
+        let renderStatsAvailable = false;
+        if (strict2) {
+          try {
+            const renderHost = Reflect.get(window, "__sootsimRenderHost");
+            const queryStats = typeof renderHost === "object" && renderHost !== null ? Reflect.get(renderHost, "queryStats") : null;
+            const stats = typeof queryStats === "function" ? await queryStats.call(renderHost) : null;
+            renderStatsAvailable = !!stats;
+            auxSurfaceDebug = stats?.auxSurfaceDebug ?? null;
+            animating = stats?.hasActiveAnims === true || stats?.hasActiveNativeAnimations === true || stats?.hasPendingAnimationFrames === true;
+            layoutDirty = stats?.layoutDirty === true && stats?.renderRequested === true;
+          } catch {
+          }
+        }
+        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 {
+          animating,
+          auxSurfaceDebug,
+          layout,
+          layoutDirty,
+          renderStatsAvailable
+        };
+      };
+      let stableLayout = null;
+      let stable = 0;
+      let lastSnapshot = null;
+      while (Date.now() < deadline) {
+        const snapshot = await readSnapshot();
+        lastSnapshot = snapshot;
+        if ((!strict2 || snapshot.renderStatsAvailable) && !snapshot.animating && !snapshot.layoutDirty && isLayoutStable(stableLayout, snapshot.layout)) {
+          stable++;
+          if (stable >= requiredStablePolls) {
+            return { settled: true, elapsed: Date.now() - start };
+          }
+        } else {
+          stableLayout = snapshot.layout;
+          stable = 0;
+        }
+        await sleep(pollMs);
+      }
+      return {
+        settled: false,
+        elapsed: Date.now() - start,
+        reason: transitionError ? `layout fallback after screen transition wait failed: ${transitionError}` : strict2 ? `strict idle state unavailable: renderStats=${lastSnapshot?.renderStatsAvailable === true} animating=${lastSnapshot?.animating === true} layoutDirty=${lastSnapshot?.layoutDirty === true} layoutNodes=${(lastSnapshot?.layout.length ?? 0) / 4} aux=${JSON.stringify(lastSnapshot?.auxSurfaceDebug)}` : "layout fallback"
+      };
+    },
+    { maxMs, strict }
+  );
+  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);
+      const indexed = indexedMatcher.type === "text" ? results.filter(
+        (node) => node.type === "text" && node.text === indexedMatcher.value
+      ) : results;
+      return indexed[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 viewport = await readSootsimInteractiveViewport(page);
+  const fullFrameTolerance = 0.5;
+  const canTapCenter = 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 && center.x >= 0 && center.y >= 0 && center.x < viewport.width && center.y < viewport.height;
+  if (canTapCenter) return center;
+  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(
+      `rnx 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("rnx screenshot bridge is not installed");
+      }
+      return screenshot(captureOpts);
+    },
+    { crop: opts?.crop, format: "png" }
+  );
+  if (!dataUrl) {
+    throw new Error("rnx screenshot bridge returned an empty image");
+  }
+  return decodePngDataUrl(dataUrl);
+}
+async function setSootsimCursorCaptureActive(page, active) {
+  await page.evaluate(async (captureActive) => {
+    const bridge = window.__sootsimTest;
+    if (typeof bridge?.setCursorCaptureActive !== "function") {
+      throw new Error("sootsim cursor capture control is not installed");
+    }
+    await bridge.setCursorCaptureActive(captureActive);
+  }, active);
+}
+async function captureSootsimPng(opts) {
+  const page = getPage();
+  await setSootsimCursorCaptureActive(page, true);
+  try {
+    const deadline = Date.now() + 8e3;
+    let previous = null;
+    let identicalFrames = 1;
+    let attempts = 0;
+    while (Date.now() < deadline) {
+      await waitForSootsimIdle(page, Math.max(1, deadline - Date.now()), true);
+      const current = await captureSootsimPngFast(opts);
+      attempts++;
+      if ((0, import_proof_frame.framesIdentical)(previous, current)) {
+        identicalFrames++;
+        if (identicalFrames >= import_proof_frame.REQUIRED_IDENTICAL_PROOF_FRAMES) return current;
+      } else {
+        identicalFrames = 1;
+      }
+      previous = current;
+    }
+    throw new Error(
+      `rnx screenshot did not reach ${import_proof_frame.REQUIRED_IDENTICAL_PROOF_FRAMES} identical idle frames in ${attempts} captures`
+    );
+  } finally {
+    await setSootsimCursorCaptureActive(page, false);
+  }
+}
+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);
+}
+var MAX_SETTLED_SPEED_PT_PER_SEC = 2;
+async function waitForFrameClock(page, minMs = 25) {
+  const start = performance.now();
+  await page.evaluate(
+    () => new Promise((resolve) => {
+      const timeoutId = setTimeout(() => resolve(), 50);
+      requestAnimationFrame(() => {
+        clearTimeout(timeoutId);
+        resolve();
+      });
+    })
+  );
+  const elapsed = performance.now() - start;
+  if (elapsed < minMs) {
+    await page.waitForTimeout(minMs - elapsed);
+  }
+}
+async function findStableNodeByMatcher(matcher, action = "tap", maxWaitMs = 1500) {
+  const page = getPage();
+  const start = performance.now();
+  let lastPos = null;
+  let lastTime = null;
+  let lastRate = null;
+  let sampleCount = 0;
+  let stablePolls = 0;
+  const requiredStable = 2;
+  let hadNumericLayout = false;
+  let disappearedMidWait = false;
+  while (performance.now() - start < maxWaitMs) {
+    const node = await findNodeByMatcher(matcher);
+    if (!node) {
+      if (hadNumericLayout) {
+        disappearedMidWait = true;
+      } else {
+        return null;
+      }
+    } else {
+      disappearedMidWait = false;
+      const pos = node.absolutePosition ?? node.layout;
+      if (pos && typeof pos.x === "number" && typeof pos.y === "number") {
+        hadNumericLayout = true;
+        sampleCount++;
+        const now = performance.now();
+        if (lastPos && lastTime !== null) {
+          const dtSec = (now - lastTime) / 1e3;
+          if (dtSec > 5e-3) {
+            const vx = Math.abs(pos.x - lastPos.x) / dtSec;
+            const vy = Math.abs(pos.y - lastPos.y) / dtSec;
+            const speed = Math.sqrt(vx * vx + vy * vy);
+            lastRate = { vx, vy, speed };
+            if (speed < MAX_SETTLED_SPEED_PT_PER_SEC) {
+              stablePolls++;
+              if (stablePolls >= requiredStable) {
+                return node;
+              }
+            } else {
+              stablePolls = 0;
+            }
+          }
+        }
+        lastPos = { x: pos.x, y: pos.y };
+        lastTime = now;
+      }
+    }
+    await waitForFrameClock(page, 25);
+  }
+  const elapsed = Math.round(performance.now() - start);
+  if (disappearedMidWait) {
+    throw new Error(
+      `element disappeared while waiting to come to rest for ${action}: ${JSON.stringify(matcher)} after ${elapsed}ms`
+    );
+  }
+  if (!hadNumericLayout) {
+    throw new Error(
+      `element layout is not available for ${action}: ${JSON.stringify(matcher)} after ${elapsed}ms`
+    );
+  }
+  if (sampleCount < 2 || lastRate === null) {
+    throw new Error(
+      `element did not come to rest for ${action}: ${JSON.stringify(matcher)}; only one sample obtained after ${elapsed}ms`
+    );
+  }
+  throw new Error(
+    `element did not come to rest for ${action}: ${JSON.stringify(matcher)}; still moving ${lastRate.vx.toFixed(1)} points/sec x / ${lastRate.vy.toFixed(1)} points/sec y after ${elapsed}ms`
+  );
+}
+function createSootSimElement(matcher) {
+  const el = {
+    _matcher: matcher,
+    async tap(point) {
+      const page = getPage();
+      await waitForSootsimWorkletsIdle(page, 3e3);
+      const node = await findStableNodeByMatcher(matcher, "tap");
+      if (!node) throw new Error(`element not found for tap: ${JSON.stringify(matcher)}`);
+      if (!isNodeVisible(node)) {
+        throw new Error(
+          `Cannot perform action due to constraint failure: element not visible (${describeNodeVisibility(node)}): ${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 findStableNodeByMatcher(matcher, "multiTap");
+      if (!node)
+        throw new Error(`element not found for multiTap: ${JSON.stringify(matcher)}`);
+      if (!isNodeVisible(node)) {
+        throw new Error(
+          `Cannot perform action due to constraint failure: element not visible (${describeNodeVisibility(node)}): ${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);
+    },
+    // mirrors detox element.longPress(duration) and longPress(point, duration),
+    // where the point is relative to the element's origin
+    async longPress(pointOrDuration, durationArg = 1e3) {
+      const page = getPage();
+      const node = await findStableNodeByMatcher(matcher, "longPress");
+      if (!node)
+        throw new Error(`element not found for longPress: ${JSON.stringify(matcher)}`);
+      if (!isNodeVisible(node)) {
+        throw new Error(
+          `Cannot perform action due to constraint failure: element not visible (${describeNodeVisibility(node)}): ${JSON.stringify(matcher)}`
+        );
+      }
+      const duration = typeof pointOrDuration === "number" ? pointOrDuration : durationArg;
+      const target = typeof pointOrDuration === "object" ? {
+        x: node.absolutePosition.x + pointOrDuration.x,
+        y: node.absolutePosition.y + pointOrDuration.y
+      } : 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: target.x, y: target.y }
+      );
+      await page.waitForTimeout(50);
+    },
+    async longPressAndDrag(duration, normalizedStartX, normalizedStartY, targetElement, normalizedEndX, normalizedEndY, speed = "fast", holdDuration = 0) {
+      const page = getPage();
+      const srcNode = await findStableNodeByMatcher(matcher, "longPressAndDrag");
+      if (!srcNode)
+        throw new Error(`source element not found: ${JSON.stringify(matcher)}`);
+      const tgtNode = await findStableNodeByMatcher(
+        targetElement._matcher,
+        "longPressAndDrag"
+      );
+      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();
+      const node = await findNodeByMatcher(matcher);
+      if (matcher.type === "id" && typeof node?.nodeId === "number" && node.nodeId >= 1073741824) {
+        const replaced = await page.evaluate(
+          async ({ id, value: value2 }) => {
+            const mainShell = window.SootSim?.bridges?.mainShell;
+            if (typeof mainShell?.callTestBridge !== "function") return false;
+            return mainShell.callTestBridge("replaceTextByTestId", id, value2);
+          },
+          { id: matcher.value, value: text }
+        );
+        if (replaced === true) return;
+      }
+      await focusElementForTextEntry(el);
+      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, startPositionX, startPositionY) {
+      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, startPositionX, startPositionY);
+    },
+    async scrollTo(edge, startPositionX, startPositionY) {
+      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 normalizedStartX = resolveScrollStartPosition(
+        startPositionX,
+        "scrollTo startPositionX"
+      );
+      const normalizedStartY = resolveScrollStartPosition(
+        startPositionY,
+        "scrollTo startPositionY"
+      );
+      const hitX = node.absolutePosition.x + node.layout.width * normalizedStartX;
+      const hitY = node.absolutePosition.y + node.layout.height * normalizedStartY;
+      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 findStableNodeByMatcher(matcher, "swipe");
+      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 findStableNodeByMatcher(matcher, "setColumnToValue");
+      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 findStableNodeByMatcher(matcher, "pinch");
+      if (!node)
+        throw new Error(`element not found for pinch: ${JSON.stringify(matcher)}`);
+      if (!node.nativePinchEnabled) {
+        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 findStableNodeByMatcher(matcher, "rotate");
+      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 (_browserCompromised) {
+      throw new Error(`sootsim browser is compromised: ${_browserCompromised}`);
+    }
+    if (_page && opts?.newInstance === false && !opts.delete && !opts.recordVideoDir && _suspendedAppId) {
+      const page = _page;
+      const appId = _suspendedAppId;
+      await page.evaluate(
+        (id) => window.SootSim?.bridges?.mainShell?.launchApp?.(id),
+        appId
+      );
+      await pollUntil(
+        () => page.evaluate(async (id) => {
+          const state = await window.SootSim?.bridges?.mainShell?.getState?.();
+          return state?.state === "app" && state.activeApp === id && state.switcherPhase === "idle";
+        }, appId),
+        Boolean,
+        {
+          timeoutMs: 1e4,
+          label: `SootSim app ${appId} to resume`
+        }
+      );
+      _suspendedAppId = null;
+      await waitForSootsimTree(page, 1e4);
+      return;
+    }
+    if (!_browser) {
+      const launched = await launchReapedChromeScoped(
+        (options) => import_playwright.chromium.launch(options),
+        { headless: true, ignoreDefaultArgs: ["--disable-popup-blocking"] }
+      );
+      _browser = launched.browser;
+      _reapBrowserNow = launched.reapNow;
+      browserIdentity = ++nextBrowserIdentity;
+    }
+    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 }
+        };
+      }
+      const newContextIdentity = ++nextContextIdentity;
+      try {
+        _context = await withLifecycleTimeout(
+          "_browser.newContext()",
+          newContextIdentity,
+          () => _browser.newContext(contextOpts)
+        );
+      } catch (error) {
+        _browserCompromised = error instanceof Error ? error.message : String(error);
+        reapOwnedBrowser();
+        throw error;
+      }
+      await _context.exposeBinding("__sootsimHostCapture", async (source, value) => {
+        const request = readBrowserCompositeCaptureRequest(value);
+        const session = await source.page.context().newCDPSession(source.page);
+        try {
+          const result = await session.send("Page.captureScreenshot", {
+            format: "png",
+            fromSurface: true,
+            captureBeyondViewport: true,
+            clip: resolveBrowserCompositeCdpClip(
+              request,
+              await session.send("Page.getLayoutMetrics")
+            )
+          });
+          return "data:image/png;base64," + result.data;
+        } finally {
+          await session.detach();
+        }
+      });
+      try {
+        _page = await withLifecycleTimeout(
+          "_context.newPage()",
+          newContextIdentity,
+          () => _context.newPage()
+        );
+      } catch (error) {
+        _browserCompromised = error instanceof Error ? error.message : String(error);
+        reapOwnedBrowser();
+        throw error;
+      }
+      contextIdentity = newContextIdentity;
+    }
+    const url = opts?.url || BASE_URL;
+    device._currentUrl = url;
+    await navigateSootsimPage(_page, url, {
+      browserId: browserIdentity,
+      contextId: contextIdentity,
+      operation: "launchApp"
+    });
+    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 navigateSootsimPage(page, url.url, {
+      browserId: browserIdentity,
+      contextId: contextIdentity,
+      operation: "openURL"
+    });
+    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 — @rnx/plugin-recording). this is the
+  // SAME code path `rnx 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 `rnx 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: "",
+  // 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()}`;
+    const settleMs = options.settleMs ?? 0;
+    if (!Number.isFinite(settleMs) || settleMs < 0) {
+      throw new Error("rnx motion capture needs a non-negative settleMs");
+    }
+    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 interact = captureWindow.SootSim?.bridges?.interact;
+        if (input.hold && (!interact || typeof interact.touchDown !== "function")) {
+          throw new Error("rnx interact bridge is not installed");
+        }
+        const frameMs = 1e3 / 60;
+        const controller = await lockstep.begin(60);
+        const moves = input.hold?.moves ?? [];
+        const holdState = {
+          nextMove: 0,
+          pressFrameIndex: null,
+          released: false,
+          x: input.hold?.x ?? 0,
+          y: input.hold?.y ?? 0
+        };
+        const holdEventFrameIndex = (afterMs) => (holdState.pressFrameIndex ?? 0) + Math.ceil(afterMs / frameMs);
+        const nextHoldEventFrameIndex = () => {
+          if (!input.hold || holdState.released || holdState.pressFrameIndex === null) {
+            return null;
+          }
+          const move = moves[holdState.nextMove];
+          return holdEventFrameIndex(move ? move.afterMs : input.hold.durationMs);
+        };
+        const advanceHold = async (receipt) => {
+          if (!input.hold || !interact || holdState.released) return;
+          if (holdState.pressFrameIndex === null) {
+            holdState.pressFrameIndex = receipt.frameIndex - 1;
+          }
+          for (let move = moves[holdState.nextMove]; move && receipt.frameIndex >= holdEventFrameIndex(move.afterMs); move = moves[holdState.nextMove]) {
+            holdState.nextMove++;
+            holdState.x = move.x;
+            holdState.y = move.y;
+            await interact.touchMove(move.x, move.y);
+          }
+          if (receipt.frameIndex < holdEventFrameIndex(input.hold.durationMs)) return;
+          holdState.released = true;
+          await interact.touchUp(holdState.x, holdState.y);
+        };
+        try {
+          const baselineBitmap = await captureBitmap();
+          const baseline = regionPixels(baselineBitmap);
+          baselineBitmap.close();
+          state.ready = true;
+          if (input.hold && interact) {
+            const hit = await interact.touchDown(input.hold.x, input.hold.y);
+            if (!hit) {
+              throw new Error(`rnx motion hold missed at ${input.hold.x},${input.hold.y}`);
+            }
+          } else {
+            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();
+            await advanceHold(receipt);
+            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 stageFrameIndex = visibleStart.frameIndex + Math.ceil(stage.offsetMs / frameMs);
+            for (let eventFrameIndex = nextHoldEventFrameIndex(); eventFrameIndex !== null && stageFrameIndex > eventFrameIndex; eventFrameIndex = nextHoldEventFrameIndex()) {
+              await advanceHold(await controller.stepFrame());
+            }
+            const receipt = await controller.stepToOffset(visibleStart, stage.offsetMs);
+            await advanceHold(receipt);
+            snapshots.push({
+              actualMs: receipt.virtualTimestampMs - visibleStart.virtualTimestampMs,
+              bitmap: await captureBitmap(),
+              frameIndex: receipt.frameIndex,
+              label: stage.label,
+              offsetMs: stage.offsetMs,
+              virtualTimestampMs: receipt.virtualTimestampMs
+            });
+          }
+          if (input.settleMs > 0) {
+            const maximumOffsetMs = input.stages.reduce(
+              (maximum, stage) => Math.max(maximum, stage.offsetMs),
+              0
+            );
+            await controller.stepToOffset(visibleStart, maximumOffsetMs + input.settleMs);
+          }
+          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,
+        hold: options.hold ?? null,
+        motionChangeDefinition: import_motion_change.MOTION_CHANGE_DEFINITION,
+        rootFrame: options.rootFrame ?? null,
+        settleMs,
+        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 {
+      if (!options.hold) {
+        if (typeof options.trigger !== "function") {
+          throw new Error("rnx motion capture needs a trigger or a hold");
+        }
+        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 token = `timed-${process.pid}-${Date.now()}-${Math.random()}`;
+    const capturePromise = page.evaluate(
+      async (input) => {
+        const captureWindow = window;
+        const screenshot = captureWindow.SootSim?.bridges?.screenshot;
+        const live = captureWindow.SootSim?.bridges?.liveComposite;
+        if (typeof screenshot !== "function") {
+          throw new Error("rnx screenshot bridge is not installed");
+        }
+        const registry = captureWindow.__sootsimTimedCaptures ?? (captureWindow.__sootsimTimedCaptures = {});
+        const state = {
+          anchorPerformanceMs: null,
+          anchorWallMs: null,
+          cancelled: false,
+          ready: false
+        };
+        registry[input.token] = state;
+        if (!input.skipWarmup) {
+          await screenshot({ format: "png" });
+        }
+        state.ready = true;
+        while (state.anchorPerformanceMs === null || state.anchorWallMs === null) {
+          if (state.cancelled) throw new Error("rnx timed capture was cancelled");
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        const captureAnchorMs = state.anchorWallMs;
+        const captureAnchorPerformanceMs = state.anchorPerformanceMs;
+        const snaps = await Promise.all(
+          input.stages.map(
+            (stage) => new Promise((resolve) => {
+              const fire = async () => {
+                const actualMs = performance.now() - captureAnchorPerformanceMs;
+                const captureRequestedAtMs = Date.now();
+                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,
+                    captureRequestedAtMs,
+                    dataUrl
+                  });
+                } catch {
+                  resolve({
+                    label: stage.label,
+                    offsetMs: stage.offsetMs,
+                    actualMs,
+                    captureRequestedAtMs,
+                    dataUrl: null
+                  });
+                }
+              };
+              setTimeout(
+                () => {
+                  void fire();
+                },
+                Math.max(
+                  0,
+                  captureAnchorPerformanceMs + stage.offsetMs - performance.now()
+                )
+              );
+            })
+          )
+        );
+        const out = [];
+        for (const snap of snaps) {
+          if (!snap.dataUrl) continue;
+          out.push({
+            label: snap.label,
+            offsetMs: snap.offsetMs,
+            actualMs: snap.actualMs,
+            captureRequestedAtMs: snap.captureRequestedAtMs,
+            dataUrl: snap.dataUrl
+          });
+        }
+        delete registry[input.token];
+        return { captureAnchorMs, frames: out };
+      },
+      { stages, skipWarmup: options.skipWarmup === true, token }
+    );
+    await page.waitForFunction(
+      (captureToken) => {
+        const registry = window.__sootsimTimedCaptures;
+        return registry?.[captureToken]?.ready === true;
+      },
+      token,
+      { timeout: 5e3 }
+    );
+    const armCapture = (anchorMs) => page.evaluate(
+      ({ anchorMs: anchorMs2, captureToken }) => {
+        const registry = window.__sootsimTimedCaptures;
+        const capture = registry?.[captureToken];
+        if (!capture?.ready) throw new Error("rnx timed capture was not armed");
+        const nowMs = Date.now();
+        capture.anchorWallMs = anchorMs2 ?? nowMs;
+        capture.anchorPerformanceMs = performance.now() - (nowMs - capture.anchorWallMs);
+        return capture.anchorWallMs;
+      },
+      { anchorMs, captureToken: token }
+    );
+    let triggerStartMs = 0;
+    let triggerCompletedMs = 0;
+    try {
+      let captureAnchorMs;
+      if (options.anchorAfterTrigger === false) {
+        captureAnchorMs = await armCapture();
+        triggerStartMs = captureAnchorMs;
+        const triggerPromise = Promise.resolve().then(options.trigger).then(() => {
+          triggerCompletedMs = Date.now();
+        });
+        const [capture2] = await Promise.all([capturePromise, triggerPromise]);
+        return {
+          captureAnchorMs,
+          frames: writeFastScreenshotFrames(namePrefix, capture2.frames),
+          triggerCompletedMs,
+          triggerStartMs
+        };
+      }
+      triggerStartMs = Date.now();
+      await Promise.resolve(options.trigger());
+      triggerCompletedMs = Date.now();
+      captureAnchorMs = await armCapture(triggerCompletedMs);
+      const capture = await capturePromise;
+      return {
+        captureAnchorMs,
+        frames: writeFastScreenshotFrames(namePrefix, capture.frames),
+        triggerCompletedMs,
+        triggerStartMs
+      };
+    } catch (error) {
+      await page.evaluate((captureToken) => {
+        const registry = window.__sootsimTimedCaptures;
+        const capture = registry?.[captureToken];
+        if (capture) capture.cancelled = true;
+      }, token).catch(() => {
+      });
+      await capturePromise.catch(() => {
+      });
+      throw error;
+    }
+  },
+  // 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("rnx 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);
+    }
+  },
+  // a real browser key press. host.ts turns window keydown into the
+  // `sootsim:hostKey` shell event that overlays listen to, so this drives the
+  // same path a desktop user does for keys no device button covers (Escape).
+  async pressKey(key) {
+    const page = getPage();
+    await page.keyboard.press(key);
+    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);
+    }
+  },
+  // window-point counterpart to element(...).longPress, for a target detox can
+  // only address by coordinate (a native tab cell, a shell chrome control).
+  async longPress(point, durationMs = 1e3) {
+    const page = getPage();
+    const { x, y } = point;
+    await page.evaluate(
+      async ({ x: px, y: py, ms }) => {
+        const longPress = window.SootSim?.bridges?.interact?.longPress;
+        if (typeof longPress !== "function") {
+          throw new Error("sootsim longPress bridge is not installed");
+        }
+        const hit = await longPress(px, py, ms);
+        if (!hit) {
+          throw new Error(`sootsim longPress missed at ${px},${py}`);
+        }
+      },
+      { x, y, ms: durationMs }
+    );
+    await page.waitForTimeout(50);
+    if (_synchronizationEnabled) {
+      await waitForSootsimIdle(page);
+    }
+  },
+  async sendToHome() {
+    const page = getPage();
+    _suspendedAppId = await page.evaluate(async () => {
+      const state = await window.SootSim?.bridges?.mainShell?.getState?.();
+      const appId = state?.activeApp;
+      if (typeof appId !== "string") {
+        throw new Error(`cannot send an inactive SootSim app home`);
+      }
+      window.SootSim?.bridges?.mainShell?.goHome?.();
+      return appId;
+    });
+    await pollUntil(
+      () => page.evaluate(async () => {
+        const state = await window.SootSim?.bridges?.mainShell?.getState?.();
+        return state?.state === "home" && state.switcherPhase === "idle";
+      }),
+      Boolean,
+      {
+        timeoutMs: 1e4,
+        label: "SootSim home transition"
+      }
+    );
+  },
+  // 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
+});