peachsim 0.1.577 → 0.1.579

package/dist-lib/detox/index.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.577 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.579 | (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;
@@ -11,8 +11,8 @@ 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 });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -301,13 +301,13 @@ function assertGpuBrowserCommand(command, runtime = currentRuntime()) {
       `[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));
+  for (const name2 of ["--enable-features=", "--disable-features="]) {
+    const lists = args.filter((arg) => arg.startsWith(name2)).map((arg) => arg.slice(name2.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`
+        `[reap-browser] Chrome keeps only its last ${name2.slice(0, -1)} switch, which dropped ${dropped.join(",")}; add them to the merged list in scripts/lib/reap-browser.ts`
       );
     }
   }
@@ -884,6 +884,19 @@ function isAppBootTargetUrl(initUrl) {
   }
 }
 
+// src/public-brand.ts
+var name = "Peach";
+var peachPublicBrand = Object.freeze({
+  name,
+  packageName: "peachsim",
+  commandName: "peach",
+  domain: "peachsim.com",
+  origin: "https://peachsim.com"
+});
+
+// src/menu.ts
+var SOOTSIM_SHELL_COMMAND_NAME = "sootsim:shell-command";
+
 // src/poll-until.ts
 async function pollUntil(read, ready, options) {
   if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
@@ -979,7 +992,14 @@ async function pollUntil(read, ready, options) {
   }
 }
 
+// ../peach-engine/src/engine/scroll-platform.ts
+var IOS_SCROLL_AXIS_TANGENT = Math.sqrt(3);
+function scrollTouchSlop(platform, primaryDelta) {
+  return platform === "android" ? 0 : Math.sign(primaryDelta) * 10;
+}
+
 // detox/gestures.ts
+var DETOX_PLATFORM = process.env.PEACH_PLATFORM === "android" ? "android" : "ios";
 function resolveScrollStartPosition(value, label) {
   const normalized = value === void 0 || Number.isNaN(value) ? 0.5 : value;
   if (!Number.isFinite(normalized) || normalized < 0 || normalized > 1) {
@@ -1171,23 +1191,24 @@ async function dragScrollNode(page, node, pixels, direction, startPositionX, sta
   const startSootSimY = node.absolutePosition.y + node.layout.height * normalizedStartY;
   let endSootSimX = startSootSimX;
   let endSootSimY = startSootSimY;
+  const travel = pixels + scrollTouchSlop(DETOX_PLATFORM, 1);
   switch (direction) {
     case "down":
-      endSootSimY -= pixels;
+      endSootSimY -= travel;
       break;
     case "up":
-      endSootSimY += pixels;
+      endSootSimY += travel;
       break;
     case "left":
-      endSootSimX += pixels;
+      endSootSimX += travel;
       break;
     case "right":
-      endSootSimX -= pixels;
+      endSootSimX -= travel;
       break;
   }
   const startPage = await sootsimToPage(page, startSootSimX, startSootSimY);
   const endPage = await sootsimToPage(page, endSootSimX, endSootSimY);
-  const steps = Math.max(16, Math.ceil(pixels / 8));
+  const steps = Math.max(16, Math.ceil(travel / 8));
   await page.mouse.move(startPage.x, startPage.y);
   await page.mouse.down();
   await page.waitForTimeout(20);
@@ -1197,6 +1218,7 @@ async function dragScrollNode(page, node, pixels, direction, startPositionX, sta
     await page.mouse.move(startPage.x + dx * i, startPage.y + dy * i);
     await page.waitForTimeout(24);
   }
+  await page.waitForTimeout(300);
   await page.mouse.up();
   await page.waitForTimeout(180);
 }
@@ -1861,17 +1883,23 @@ function attachPageDiagnostics(page) {
 }
 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
-    }));
+    return await page.evaluate(() => {
+      const bootMarks = Reflect.get(window, "__sootsimBootMarks");
+      return {
+        bodyText: document.body?.innerText?.slice(0, 500) ?? "",
+        bootStage: document.documentElement.dataset.sootsimBootStage ?? null,
+        bootMarks: Array.isArray(bootMarks) ? bootMarks.slice(-16) : [],
+        capturedAtEpochMs: Date.now(),
+        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)
@@ -1936,7 +1964,6 @@ function getSootsimNavigationDiagnostics(page) {
 var import_proof_frame = __toESM(require_proof_frame(), 1);
 var BASE_URL = process.env.PEACH_URL || "http://localhost:5173";
 var SCREENSHOT_DIR = process.env.PEACH_SCREENSHOT_DIR || path.join(process.cwd(), "test", "detox-driver", "screenshots");
-var DETOX_PLATFORM = process.env.PEACH_PLATFORM === "android" ? "android" : "ios";
 var _browser = null;
 var _reapBrowserNow = null;
 var _context = null;
@@ -2031,85 +2058,83 @@ async function waitForSootsimSurfaceMetrics(page, timeout = 3e4) {
 async function waitForSootsimShellReady(page, timeout = 3e4) {
   const expectsInitialAppPaint = isAppBootTargetUrl(page.url());
   try {
-    await page.evaluate(async ({ timeoutMs, expectsInitialAppPaint: expectsInitialAppPaint2 }) => {
-      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);
+    await page.evaluate(
+      async ({ timeoutMs, expectsInitialAppPaint: expectsInitialAppPaint2 }) => {
+        let deadline = Date.now() + 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";
+        let shellHost = null;
+        while (Date.now() < deadline) {
+          const candidate = window.SootSim?.bridges?.shellHost;
+          if (candidate || isTenantOnly) {
+            shellHost = candidate ?? null;
+            break;
+          }
+          await sleep(25);
         }
-      };
-      const isTenantOnly = new URL(window.location.href).searchParams.get("renderMode") === "tenant-only";
-      let shellHost = null;
-      while (Date.now() < deadline) {
-        const candidate = window.SootSim?.bridges?.shellHost;
-        if (candidate || isTenantOnly) {
-          shellHost = candidate ?? null;
-          break;
+        if (!shellHost) {
+          if (isTenantOnly) return;
+          throw new Error(`sootsim shell host unavailable after ${timeoutMs}ms`);
         }
-        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);
-      }
-      const isRenderHostDisposed = (error) => error instanceof Error && error.message.includes("render host disposed");
-      for (; ; ) {
-        try {
-          if (expectsInitialAppPaint2) {
-            while (Date.now() < deadline) {
-              if (document.documentElement.dataset.sootsimBootStage === "painted") {
-                break;
-              }
-              await sleep(50);
-            }
-            if (document.documentElement.dataset.sootsimBootStage !== "painted") {
-              throw new Error(
-                `sootsim app first content paint timed out after ${timeoutMs}ms`
-              );
-            }
-          } else if (shellHost.firstContentPainted && typeof shellHost.firstContentPainted.then === "function") {
-            await withTimeout(
-              "sootsim shell first content paint",
-              shellHost.firstContentPainted
-            );
+        if (shellHost.ready && typeof shellHost.ready.then === "function") {
+          await withTimeout("sootsim shell ready", shellHost.ready);
+        }
+        if (expectsInitialAppPaint2) {
+          const compositorHost = Reflect.get(window, "__sootsimCompositor");
+          if (typeof compositorHost?.firstContentPainted?.then !== "function") {
+            throw new Error("sootsim app compositor unavailable at boot");
           }
-          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)}`
+          await compositorHost.firstContentPainted;
+          deadline = Date.now() + 3e3;
+        }
+        const isRenderHostDisposed = (error) => error instanceof Error && error.message.includes("render host disposed");
+        for (; ; ) {
+          try {
+            if (!expectsInitialAppPaint2 && 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)}`
+                );
+              }
+            }
+            break;
+          } catch (error) {
+            if (!isRenderHostDisposed(error) || Date.now() >= deadline) throw error;
+            await sleep(100);
           }
-          break;
-        } catch (error) {
-          if (!isRenderHostDisposed(error) || Date.now() >= deadline) throw error;
-          await sleep(100);
         }
-      }
-    }, { timeoutMs: timeout, expectsInitialAppPaint });
+      },
+      { timeoutMs: timeout, expectsInitialAppPaint }
+    );
   } catch (error) {
     throw await describeSootsimBridgeFailure(page, error);
   }
@@ -2418,7 +2443,7 @@ async function dispatchTapAtSootsimPoint(page, x, y) {
 }
 async function isFocusedTextInputNode(page, nodeInfo) {
   const focused = await page.evaluate(
-    () => window.__sootsimTest.getFocusedNode?.() ?? null
+    async () => await window.__sootsimTest.getFocusedNode?.() ?? null
   );
   return !!focused && typeof focused === "object" && focused.nodeId === nodeInfo?.nodeId;
 }
@@ -2430,7 +2455,14 @@ async function focusElementForTextEntry(el) {
   }
   if (await isFocusedTextInputNode(page, node)) return;
   await el.tap();
-  await page.waitForTimeout(100);
+  await pollUntil(
+    () => page.evaluate(async () => (await window.__sootsimTest.getFocusedNode?.())?.nodeId ?? null),
+    (focusedNodeId) => focusedNodeId === node.nodeId,
+    {
+      timeoutMs: 5e3,
+      label: `SootSim text input ${node.nodeId} to focus`
+    }
+  );
 }
 function ensureScreenshotDir() {
   if (!fs.existsSync(SCREENSHOT_DIR)) {
@@ -2512,9 +2544,9 @@ async function captureSootsimPng(opts) {
     await setSootsimCursorCaptureActive(page, false);
   }
 }
-async function writeSootsimScreenshot(name, opts) {
+async function writeSootsimScreenshot(name2, opts) {
   ensureScreenshotDir();
-  const screenshotPath = path.join(SCREENSHOT_DIR, `${name}.png`);
+  const screenshotPath = path.join(SCREENSHOT_DIR, `${name2}.png`);
   fs.writeFileSync(screenshotPath, await captureSootsimPng(opts));
   return screenshotPath;
 }
@@ -2533,6 +2565,24 @@ async function dispatchStatusBarOverride(config) {
   );
   await page.waitForTimeout(50);
 }
+async function dispatchDeviceOrientation(orientation) {
+  const page = getPage();
+  await page.evaluate(
+    ({ eventType, next, landscapeSide }) => {
+      window.dispatchEvent(
+        new CustomEvent(eventType, {
+          detail: { type: "set-device-orientation", orientation: next, landscapeSide }
+        })
+      );
+    },
+    {
+      eventType: SOOTSIM_SHELL_COMMAND_NAME,
+      next: orientation,
+      landscapeSide: DETOX_PLATFORM === "ios" ? "right" : "left"
+    }
+  );
+  await page.waitForTimeout(50);
+}
 var MAX_SETTLED_SPEED_PT_PER_SEC = 2;
 async function waitForFrameClock(page, minMs = 25) {
   const start = performance.now();
@@ -2686,10 +2736,7 @@ function createSootSimElement(matcher) {
           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}`);
-          }
+          await longPress(x, y, duration2);
         },
         { duration, x: target.x, y: target.y }
       );
@@ -2714,15 +2761,25 @@ function createSootSimElement(matcher) {
       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;
+      const pace = 25 * (speed === "slow" ? 0.1 : 0.5);
+      const steps = Math.max(
+        1,
+        Math.round(
+          Math.max(
+            Math.abs(endSootSimX - startSootSimX),
+            Math.abs(endSootSimY - startSootSimY)
+          ) / pace
+        )
+      );
+      const frameMs = 1e3 / 60;
       await page.mouse.move(startPage.x, startPage.y);
       await page.mouse.down();
-      await page.waitForTimeout(Math.max(duration, holdDuration));
+      await page.waitForTimeout(duration);
       const dx = (endPage.x - startPage.x) / steps;
       const dy = (endPage.y - startPage.y) / steps;
-      for (let i = 1; i <= steps; i++) {
+      for (let i = 1; i <= steps + 1; i++) {
+        await page.waitForTimeout(i === steps + 1 ? holdDuration : frameMs);
         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);
@@ -2747,6 +2804,7 @@ function createSootSimElement(matcher) {
         if (replaced === true) return;
       }
       await focusElementForTextEntry(el);
+      await page.keyboard.press("End");
       const value = typeof node?.text === "string" ? node.text : "";
       for (let i = 0; i < value.length; i++) {
         await page.keyboard.press("Backspace");
@@ -2756,6 +2814,7 @@ function createSootSimElement(matcher) {
     async clearText() {
       const page = getPage();
       await focusElementForTextEntry(el);
+      await page.keyboard.press("End");
       const node = await findNodeByMatcher(matcher);
       const value = typeof node?.text === "string" ? node.text : "";
       for (let i = 0; i < value.length; i++) {
@@ -2982,7 +3041,7 @@ function createSootSimElement(matcher) {
         stepDelayMs: speed === "fast" ? 14 : 24
       });
     },
-    async takeScreenshot(name) {
+    async takeScreenshot(name2) {
       const node = await findNodeByMatcher(matcher);
       if (!node)
         throw new Error(
@@ -2994,7 +3053,7 @@ function createSootSimElement(matcher) {
         width: node.layout.width,
         height: node.layout.height
       };
-      return writeSootsimScreenshot(name, {
+      return writeSootsimScreenshot(name2, {
         crop: {
           x: box.x,
           y: box.y,
@@ -3160,14 +3219,14 @@ var device = {
     await waitForSootsimShellReady(page, 1e4);
     await waitForSootsimWorkletsIdle(page, 3e3);
   },
-  async takeScreenshot(name) {
-    return writeSootsimScreenshot(name);
+  async takeScreenshot(name2) {
+    return writeSootsimScreenshot(name2);
   },
   // single-shot variant for multi-stage animation captures. skips the
   // frame-stability poll so callers can sample mid-transition.
-  async takeScreenshotFast(name) {
+  async takeScreenshotFast(name2) {
     ensureScreenshotDir();
-    const screenshotPath = path.join(SCREENSHOT_DIR, `${name}.png`);
+    const screenshotPath = path.join(SCREENSHOT_DIR, `${name2}.png`);
     fs.writeFileSync(screenshotPath, await captureSootsimPngFast());
     return screenshotPath;
   },
@@ -3337,6 +3396,7 @@ var device = {
           snapshot.bitmap.close();
           return {
             actualMs: snapshot.actualMs,
+            anchorId: snapshot.anchorId,
             dataUrl: canvas.toDataURL("image/png"),
             label: snapshot.label,
             offsetMs: snapshot.offsetMs,
@@ -3381,6 +3441,7 @@ var device = {
           holdState.released = true;
           await interact.touchUp(holdState.x, holdState.y);
         };
+        const keptFrames = /* @__PURE__ */ new Map();
         try {
           const baselineBitmap = await captureBitmap();
           const baseline = regionPixels(baselineBitmap);
@@ -3389,7 +3450,9 @@ var device = {
           if (input.hold && interact) {
             const hit = await interact.touchDown(input.hold.x, input.hold.y);
             if (!hit) {
-              throw new Error(`peach motion hold missed at ${input.hold.x},${input.hold.y}`);
+              throw new Error(
+                `peach motion hold missed at ${input.hold.x},${input.hold.y}`
+              );
             }
           } else {
             while (!state.triggerCompleted) {
@@ -3399,6 +3462,8 @@ var device = {
           }
           let visibleStart = null;
           let detectedMeasurement = null;
+          let previousReceipt = null;
+          let previousBitmap = null;
           const detectionFrameLimit = Math.ceil(input.detectionTimeoutMs * 60 / 1e3);
           for (let frame = 0; frame < detectionFrameLimit; frame++) {
             if (state.cancelled) throw new Error("peach motion capture was cancelled");
@@ -3414,29 +3479,137 @@ var device = {
               label: "SootSim visible-change detector",
               width: bounds.width
             });
-            candidateBitmap.close();
             if (measurement.passedMinimum) {
+              candidateBitmap.close();
               visibleStart = receipt;
               detectedMeasurement = measurement;
               break;
             }
+            previousBitmap?.close();
+            previousBitmap = candidateBitmap;
+            previousReceipt = receipt;
+          }
+          if (previousReceipt && previousBitmap) {
+            keptFrames.set(previousReceipt.frameIndex, previousBitmap);
           }
           if (!visibleStart || !detectedMeasurement) {
             throw new Error(
               `peach motion had no visible change before ${input.detectionTimeoutMs}ms`
             );
           }
+          const driveStart = previousReceipt ?? visibleStart;
+          let currentReceipt = visibleStart;
+          const resolvedAnchors = /* @__PURE__ */ new Map();
+          const anchorRecords = [];
+          const resolveAnchor = async (stage) => {
+            const anchor = stage.anchor;
+            if (!anchor) return { anchorId: "transition", receipt: driveStart };
+            const known = resolvedAnchors.get(anchor.id);
+            if (known) return { anchorId: anchor.id, receipt: known };
+            if (typeof anchor.notBeforeMs !== "number" || !Number.isFinite(anchor.notBeforeMs) || anchor.notBeforeMs < 0) {
+              throw new Error(
+                `peach motion stage ${stage.label} anchor ${anchor.id} needs a non-negative notBeforeMs`
+              );
+            }
+            const onsetThresholdPercent = anchor.onsetThresholdPercent ?? 5;
+            const searchStartVts = driveStart.virtualTimestampMs + anchor.notBeforeMs;
+            if (currentReceipt.virtualTimestampMs > searchStartVts) {
+              throw new Error(
+                `peach motion anchor ${anchor.id} searches from ${anchor.notBeforeMs}ms but the clock already sits past it: the ladder is unexecutable`
+              );
+            }
+            let searchReceipt = currentReceipt;
+            while (searchReceipt.virtualTimestampMs < searchStartVts) {
+              if (state.cancelled) throw new Error("peach motion capture was cancelled");
+              searchReceipt = await controller.stepFrame();
+              await advanceHold(searchReceipt);
+            }
+            currentReceipt = searchReceipt;
+            let anchorBitmap = await captureBitmap();
+            let previousPixels = regionPixels(anchorBitmap);
+            let anchorReceipt = searchReceipt;
+            let onsetMeasurement = null;
+            let panPeakPercent = 0;
+            let latePeakPercent = 0;
+            for (let frame = 0; frame < detectionFrameLimit; frame++) {
+              if (state.cancelled) throw new Error("peach motion capture was cancelled");
+              const receipt = await controller.stepFrame();
+              await advanceHold(receipt);
+              const candidateBitmap = await captureBitmap();
+              const bounds = boundsFor(candidateBitmap);
+              const candidate = regionPixels(candidateBitmap);
+              const measurement = measureChange({
+                baseline: previousPixels,
+                candidate,
+                definition: {
+                  ...input.motionChangeDefinition,
+                  minimumChangePercent: onsetThresholdPercent
+                },
+                height: bounds.height,
+                label: `SootSim second-drive detector ${anchor.id}`,
+                width: bounds.width
+              });
+              previousPixels = candidate;
+              currentReceipt = receipt;
+              if (receipt.virtualTimestampMs - searchStartVts < 250) {
+                panPeakPercent = Math.max(panPeakPercent, measurement.changePercent);
+              } else {
+                latePeakPercent = Math.max(latePeakPercent, measurement.changePercent);
+              }
+              if (measurement.passedMinimum) {
+                candidateBitmap.close();
+                onsetMeasurement = measurement;
+                break;
+              }
+              anchorBitmap.close();
+              anchorBitmap = candidateBitmap;
+              anchorReceipt = receipt;
+            }
+            if (!onsetMeasurement) {
+              anchorBitmap.close();
+              throw new Error(
+                `peach motion anchor ${anchor.id} found no onset past ${onsetThresholdPercent}% within ${input.detectionTimeoutMs}ms of ${anchor.notBeforeMs}ms (pan peak ${panPeakPercent.toFixed(2)}%, later peak ${latePeakPercent.toFixed(2)}%): the gate or the search start is wrong for this surface`
+              );
+            }
+            keptFrames.get(anchorReceipt.frameIndex)?.close();
+            keptFrames.set(anchorReceipt.frameIndex, anchorBitmap);
+            resolvedAnchors.set(anchor.id, anchorReceipt);
+            anchorRecords.push({
+              changedPixelPercent: onsetMeasurement.changePercent,
+              frameIndex: anchorReceipt.frameIndex,
+              id: anchor.id,
+              notBeforeMs: anchor.notBeforeMs,
+              virtualTimestampMs: anchorReceipt.virtualTimestampMs
+            });
+            return { anchorId: anchor.id, receipt: anchorReceipt };
+          };
           const snapshots = [];
           for (const stage of input.stages) {
             if (state.cancelled) throw new Error("peach motion capture was cancelled");
-            const stageFrameIndex = visibleStart.frameIndex + Math.ceil(stage.offsetMs / frameMs);
+            const { anchorId, receipt: anchorReceipt } = await resolveAnchor(stage);
+            const stageFrameIndex = anchorReceipt.frameIndex + Math.ceil(stage.offsetMs / frameMs);
+            const kept = keptFrames.get(stageFrameIndex);
+            if (kept && stageFrameIndex < currentReceipt.frameIndex) {
+              snapshots.push({
+                actualMs: 0,
+                anchorId,
+                bitmap: await createImageBitmap(kept),
+                frameIndex: anchorReceipt.frameIndex,
+                label: stage.label,
+                offsetMs: stage.offsetMs,
+                virtualTimestampMs: anchorReceipt.virtualTimestampMs
+              });
+              continue;
+            }
             for (let eventFrameIndex = nextHoldEventFrameIndex(); eventFrameIndex !== null && stageFrameIndex > eventFrameIndex; eventFrameIndex = nextHoldEventFrameIndex()) {
               await advanceHold(await controller.stepFrame());
             }
-            const receipt = await controller.stepToOffset(visibleStart, stage.offsetMs);
+            const receipt = await controller.stepToOffset(anchorReceipt, stage.offsetMs);
             await advanceHold(receipt);
+            currentReceipt = receipt;
             snapshots.push({
-              actualMs: receipt.virtualTimestampMs - visibleStart.virtualTimestampMs,
+              actualMs: receipt.virtualTimestampMs - anchorReceipt.virtualTimestampMs,
+              anchorId,
               bitmap: await captureBitmap(),
               frameIndex: receipt.frameIndex,
               label: stage.label,
@@ -3444,14 +3617,28 @@ var device = {
               virtualTimestampMs: receipt.virtualTimestampMs
             });
           }
+          let releasedOffsetMs = 0;
+          while (nextHoldEventFrameIndex() !== null) {
+            const receipt = await controller.stepFrame();
+            await advanceHold(receipt);
+            releasedOffsetMs = receipt.virtualTimestampMs - driveStart.virtualTimestampMs;
+          }
           if (input.settleMs > 0) {
-            const maximumOffsetMs = input.stages.reduce(
-              (maximum, stage) => Math.max(maximum, stage.offsetMs),
-              0
+            const maximumPrimaryMs = snapshots.reduce(
+              (maximum, snapshot) => Math.max(
+                maximum,
+                snapshot.virtualTimestampMs - driveStart.virtualTimestampMs
+              ),
+              releasedOffsetMs
             );
-            await controller.stepToOffset(visibleStart, maximumOffsetMs + input.settleMs);
+            await controller.stepToOffset(driveStart, maximumPrimaryMs + input.settleMs);
           }
           return {
+            anchors: anchorRecords,
+            driveStart: {
+              frameIndex: driveStart.frameIndex,
+              virtualTimestampMs: driveStart.virtualTimestampMs
+            },
             frames: snapshots.map(encode),
             visibleChangeDetection: {
               actualMs: visibleStart.frameIndex * 1e3 / 60,
@@ -3465,6 +3652,7 @@ var device = {
             }
           };
         } finally {
+          for (const bitmap of keptFrames.values()) bitmap.close();
           controller.end();
           delete registry[input.token];
         }
@@ -3506,6 +3694,8 @@ var device = {
       }, token);
       const capture = await capturePromise;
       return {
+        anchors: capture.anchors,
+        driveStart: capture.driveStart,
         frames: writeFastScreenshotFrames(namePrefix, capture.frames),
         triggerCompletedMs,
         triggerStartMs,
@@ -3739,6 +3929,15 @@ var device = {
   async setStatusBar(config) {
     await dispatchStatusBarOverride(config);
   },
+  async setOrientation(orientation) {
+    const next = orientation === "portrait" ? "portrait" : orientation === "landscape" ? "landscape" : null;
+    if (!next) {
+      throw new Error(
+        `sootsim device.setOrientation supports portrait and landscape; got ${orientation}`
+      );
+    }
+    await dispatchDeviceOrientation(next);
+  },
   async setURLBlacklist(urls) {
   },
   async enableSynchronization() {