peachsim 0.1.1635 → 0.1.1641

package/dist-lib/detox/index.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1635 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1641 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;
@@ -1147,6 +1147,32 @@ var require_lib = __commonJS({
   }
 });
 
+// ../peach-engine/src/platform/adapter.ts
+var IOS_ADAPTER, ANDROID_ADAPTER, RUNTIME_PLATFORM_ADAPTERS;
+var init_adapter = __esm({
+  "../peach-engine/src/platform/adapter.ts"() {
+    "use strict";
+    IOS_ADAPTER = Object.freeze({
+      id: "ios",
+      displayName: "iOS",
+      isIOS: true,
+      isAndroid: false,
+      select: (registry) => registry.ios
+    });
+    ANDROID_ADAPTER = Object.freeze({
+      id: "android",
+      displayName: "Android",
+      isIOS: false,
+      isAndroid: true,
+      select: (registry) => registry.android
+    });
+    RUNTIME_PLATFORM_ADAPTERS = Object.freeze({
+      ios: IOS_ADAPTER,
+      android: ANDROID_ADAPTER
+    });
+  }
+});
+
 // detox/motion-change.cjs
 var require_motion_change = __commonJS({
   "detox/motion-change.cjs"(exports2, module2) {
@@ -1220,29 +1246,48 @@ var require_motion_change = __commonJS({
     var SETTLE_BLIP_MAXIMUM_CHANGE_PERCENT = 0.6;
     var GESTURE_MOTION_MIN_TRANSITIONS = 120;
     var GESTURE_TRAVEL_RATIO_RANGE = Object.freeze({ min: 0.8, max: 1.25 });
+    var GESTURE_QUARTER_TRAVEL_RATIO_RANGE = Object.freeze({ min: 0.5, max: 2 });
     function evaluateMotionTransitions(transitions, oracleTarget) {
       const key = (transition) => `${transition.fromLabel}\0${transition.toLabel}`;
       const oracle = transitions.filter((transition) => transition.target === oracleTarget);
       const sootsim = transitions.filter((transition) => transition.target === "sootsim");
-      const sootsimByKey = new Map(sootsim.map((transition) => [key(transition), transition]));
+      const paired = oracle.length === sootsim.length && new Set(oracle.map(key)).size === oracle.length && oracle.every((transition, index) => key(transition) === key(sootsim[index]));
       const measured = transitions.every(
         (transition) => transition.dimensionsMatch && transition.changePercent !== null && transition.changePixels !== null && transition.totalPixels !== null
       );
-      const moving = oracle.filter((transition) => transition.passedMinimum);
       const travel = (list) => list.filter(
         (transition) => transition.changePercent >= PAIRED_MOTION_MINIMUM_CHANGE_PERCENT
       ).reduce((total, transition) => total + transition.changePercent, 0);
-      const sootsimMovesNear = (index) => [index - 1, index, index + 1].some(
-        (neighbour) => sootsim[neighbour]?.passedMinimum === true
+      const movesNear = (list, index) => [index - 1, index, index + 1].some((neighbour) => list[neighbour]?.passedMinimum === true);
+      const pairedChange = (transition) => transition.changePercent >= PAIRED_MOTION_MINIMUM_CHANGE_PERCENT;
+      const settleBlip = (list) => {
+        const index = list.findLastIndex(pairedChange);
+        return index >= 0 && list[index].changePercent < SETTLE_BLIP_MAXIMUM_CHANGE_PERCENT && !(list[index - 1]?.passedMinimum ?? true) ? index : -1;
+      };
+      const oracleBlip = settleBlip(oracle);
+      const sootsimBlip = settleBlip(sootsim);
+      const moving = oracle.filter(
+        (transition, index) => pairedChange(transition) && index !== oracleBlip
       );
-      const isSettleBlip = (transition, index) => transition.changePercent < SETTLE_BLIP_MAXIMUM_CHANGE_PERCENT && !(oracle[index - 1]?.passedMinimum ?? true);
       const within = (actual, expected, range) => actual >= expected * range.min && actual <= expected * range.max;
-      const follows = oracle.length >= GESTURE_MOTION_MIN_TRANSITIONS ? within(travel(sootsim), travel(oracle), GESTURE_TRAVEL_RATIO_RANGE) : oracle.every(
-        (transition, index) => !transition.passedMinimum || transition.changePercent < PAIRED_MOTION_MINIMUM_CHANGE_PERCENT || isSettleBlip(transition, index) || sootsimByKey.has(key(transition)) && sootsimMovesNear(index)
+      const quarter = (list, index) => list.slice(
+        Math.floor(list.length * index / 4),
+        Math.floor(list.length * (index + 1) / 4)
+      );
+      const follows = oracle.length >= GESTURE_MOTION_MIN_TRANSITIONS ? within(travel(sootsim), travel(oracle), GESTURE_TRAVEL_RATIO_RANGE) && [0, 1, 2, 3].every(
+        (index) => within(
+          travel(quarter(sootsim, index)),
+          travel(quarter(oracle, index)),
+          GESTURE_QUARTER_TRAVEL_RATIO_RANGE
+        )
+      ) : oracle.every(
+        (transition, index) => !pairedChange(transition) || index === oracleBlip || movesNear(sootsim, index)
+      ) && sootsim.every(
+        (transition, index) => !pairedChange(transition) || index === sootsimBlip || movesNear(oracle, index)
       );
       return {
         moving: moving.length,
-        passed: measured && oracle.length > 0 && sootsim.length === oracle.length && moving.length > 0 && follows
+        passed: measured && oracle.length > 0 && paired && moving.length > 0 && follows
       };
     }
     var DISPLAY_LINK_INTERVAL_MS = 1e3 / 60;
@@ -1396,8 +1441,78 @@ var require_motion_change = __commonJS({
       }
       return { mode: "playing", anchorMs: anchor.atMs, holds };
     }
+    var PUBLICATION_DENSE_LADDER_MIN_STAGES = 10;
+    var PUBLICATION_MIN_INTERMEDIATE_PASSES = 2;
+    function motionCycleOnsets(event, eventPath) {
+      if (!Array.isArray(event.anchors)) return [];
+      const cycles = event.anchors.filter(
+        (anchor) => typeof anchor === "object" && anchor !== null && anchor.cycle === true
+      );
+      if (cycles.length === 0) return [];
+      const finite = (value, label) => {
+        if (typeof value !== "number" || !Number.isFinite(value))
+          throw new Error(`motion event cycle ${label} has no onset time: ${eventPath}`);
+        return value;
+      };
+      const android = event.captureMode === "android-screenrecord-sequence";
+      const peach = typeof event.driveStart === "object" && event.driveStart !== null;
+      const basisMs = peach ? finite(event.driveStart.virtualTimestampMs, "transition") : android ? finite(event.triggerProducerSeconds, "transition") * 1e3 : finite(event.triggerInVideoSec, "transition") * 1e3;
+      return [
+        { id: "transition", atMs: basisMs },
+        ...cycles.map((anchor) => {
+          if (typeof anchor.id !== "string")
+            throw new Error(`motion event cycle anchor has no id: ${eventPath}`);
+          const atMs = peach ? finite(anchor.virtualTimestampMs, anchor.id) : android ? finite(anchor.producerSeconds, anchor.id) * 1e3 : finite(anchor.detection?.atSec, anchor.id) * 1e3;
+          return { id: anchor.id, atMs };
+        })
+      ];
+    }
+    var MOTION_CYCLE_PERIOD_TOLERANCE_MS = 1e3 / 60;
+    function motionCyclePeriods(reference, sootsim) {
+      const ids = (onsets) => onsets.map((onset) => onset.id).join(",");
+      if (ids(reference) !== ids(sootsim))
+        throw new Error(
+          `motion cycle anchors differ between lanes: reference [${ids(reference)}], sootsim [${ids(sootsim)}]`
+        );
+      return reference.slice(1).map((onset, index) => {
+        const referenceMs = onset.atMs - reference[index].atMs;
+        const sootsimMs = sootsim[index + 1].atMs - sootsim[index].atMs;
+        return {
+          id: onset.id,
+          passed: Math.abs(referenceMs - sootsimMs) <= MOTION_CYCLE_PERIOD_TOLERANCE_MS,
+          referenceMs,
+          sootsimMs
+        };
+      });
+    }
+    function evaluateMotionPublication(stages, transitions, oracleTarget, cycleOnsets) {
+      const cyclePeriods = motionCyclePeriods(cycleOnsets.reference, cycleOnsets.sootsim);
+      const intermediates = stages.slice(1, -1);
+      const intermediatePassed = intermediates.filter((stage) => stage.passedThreshold).length;
+      const stagesByLabel = new Map(stages.map((stage) => [stage.label, stage]));
+      const oracleMovingInto = new Set(
+        transitions.filter(
+          (transition) => transition.target === oracleTarget && (transition.changePercent >= PAIRED_MOTION_MINIMUM_CHANGE_PERCENT || transition.changePixels > 0 && stagesByLabel.get(transition.toLabel)?.oracleFromFirstPercent >= PAIRED_MOTION_MINIMUM_CHANGE_PERCENT && stagesByLabel.get(transition.toLabel)?.oracleFromLastPercent >= PAIRED_MOTION_MINIMUM_CHANGE_PERCENT)
+        ).map((transition) => transition.toLabel)
+      );
+      const movingPassed = intermediates.filter(
+        (stage) => stage.passedThreshold && oracleMovingInto.has(stage.label)
+      ).length;
+      const needsIntermediates = stages.length >= PUBLICATION_DENSE_LADDER_MIN_STAGES;
+      const first = stages[0];
+      const last = stages[stages.length - 1];
+      return {
+        passed: stages.length > 0 && first.passedThreshold && last.passedThreshold && (!needsIntermediates || movingPassed >= PUBLICATION_MIN_INTERMEDIATE_PASSES) && cyclePeriods.every((period) => period.passed) && evaluateMotionTransitions(transitions, oracleTarget).passed,
+        cyclePeriods,
+        intermediateCount: intermediates.length,
+        intermediatePassed,
+        movingPassed
+      };
+    }
     module2.exports = {
       MOTION_CHANGE_DEFINITION: MOTION_CHANGE_DEFINITION2,
+      evaluateMotionPublication,
+      motionCycleOnsets,
       measureMotionChange: measureMotionChange2,
       measureProofMotionChange,
       evaluateMotionTransitions,
@@ -1409,6 +1524,26 @@ var require_motion_change = __commonJS({
   }
 });
 
+// ../peach-engine/src/capture/frame-offset.ts
+var frame_offset_exports = {};
+__export(frame_offset_exports, {
+  frameIndexForOffset: () => frameIndexForOffset
+});
+function frameIndexForOffset(offsetMs, frameIntervalMs) {
+  if (!Number.isFinite(offsetMs) || offsetMs < 0)
+    throw new Error(`capture: invalid stage offset ${offsetMs}`);
+  if (!Number.isFinite(frameIntervalMs) || frameIntervalMs <= 0)
+    throw new Error(`capture: invalid frame interval ${frameIntervalMs}`);
+  const quotient = offsetMs / frameIntervalMs;
+  const nearest = Math.round(quotient);
+  return Math.abs(quotient - nearest) <= Number.EPSILON * Math.abs(quotient) ? nearest : Math.ceil(quotient);
+}
+var init_frame_offset = __esm({
+  "../peach-engine/src/capture/frame-offset.ts"() {
+    "use strict";
+  }
+});
+
 // ../../scripts/lib/remote-build-delivery.ts
 var remote_build_delivery_exports = {};
 __export(remote_build_delivery_exports, {
@@ -1540,6 +1675,7 @@ var require_native_frame_receipt = __commonJS({
   "../peach-conformance/e2e/utils/native-frame-receipt.cjs"(exports2, module2) {
     "use strict";
     var { createHash } = require("node:crypto");
+    var { frameIndexForOffset: frameIndexForOffset2 } = (init_frame_offset(), __toCommonJS(frame_offset_exports));
     function nativeVideoFrameReceipt(recordingSha256, sourceFrameIndex, ptsSeconds, inputClock) {
       if (!/^[a-f0-9]{64}$/.test(recordingSha256)) throw new Error("invalid recording hash");
       if (!Number.isSafeInteger(sourceFrameIndex) || sourceFrameIndex < 0)
@@ -1620,25 +1756,29 @@ var require_native_frame_receipt = __commonJS({
       if (output !== bytes.length) throw new Error("incomplete native framebuffer");
       return bytes;
     }
-    function writeNativeFramebufferPng(receipt, bytes, outputPath, expectedSize) {
+    function nativeFramebufferPixels(receipt, bytes) {
       requireNativeRawFrame(receipt, bytes);
-      const { PNG } = require("pngjs");
-      const fs3 = require("node:fs");
       const { width, height, stride } = receipt.rawFramebuffer;
-      if (width !== expectedSize.width || height !== expectedSize.height)
-        throw new Error("native framebuffer and screenshot dimensions differ");
-      const png = new PNG({ width, height });
+      const data = Buffer.allocUnsafe(width * height * 4);
       for (let y = 0; y < height; y++) {
         for (let x = 0; x < width; x++) {
           const source = y * stride + x * 4;
           const destination = (y * width + x) * 4;
-          png.data[destination] = bytes[source + 2];
-          png.data[destination + 1] = bytes[source + 1];
-          png.data[destination + 2] = bytes[source];
-          png.data[destination + 3] = bytes[source + 3];
+          data[destination] = bytes[source + 2];
+          data[destination + 1] = bytes[source + 1];
+          data[destination + 2] = bytes[source];
+          data[destination + 3] = bytes[source + 3];
         }
       }
-      fs3.writeFileSync(outputPath, PNG.sync.write(png));
+      return { width, height, data };
+    }
+    function writeNativeFramebufferPng(receipt, bytes, outputPath, expectedSize) {
+      const { PNG } = require("pngjs");
+      const fs3 = require("node:fs");
+      const pixels = nativeFramebufferPixels(receipt, bytes);
+      if (pixels.width !== expectedSize.width || pixels.height !== expectedSize.height)
+        throw new Error("native framebuffer and screenshot dimensions differ");
+      fs3.writeFileSync(outputPath, PNG.sync.write(pixels));
       return receipt;
     }
     module2.exports = {
@@ -1646,6 +1786,7 @@ var require_native_frame_receipt = __commonJS({
       requireNativeProducerFrame,
       requireNativeRawFrame,
       decodeNativeFramebuffer,
+      nativeFramebufferPixels,
       writeNativeFramebufferPng
     };
     async function buildNativeFrameConsumer({ root, cacheRoot, waitForAdmission = false }) {
@@ -1757,6 +1898,455 @@ var require_native_frame_receipt = __commonJS({
       };
     }
     module2.exports.nativeUIKitInputReceipt = nativeUIKitInputReceipt;
+    function nativeUIFrameClockReceipt(bytes) {
+      if (!Buffer.isBuffer(bytes))
+        throw new Error("ui frame clock receipt must preserve source bytes");
+      const rows = bytes.toString("utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+      if (rows.at(-1)?.kind !== "stopped")
+        throw new Error("ui frame clock receipt was not closed by its recorder");
+      const ticks = [];
+      const workletsTicks = [];
+      for (const row of rows.slice(0, -1)) {
+        if (row.kind === "worklets-frame") {
+          if (!Number.isFinite(row.timestampSeconds) || row.timestampSeconds < 0)
+            throw new Error("invalid worklets frame clock row");
+          if (workletsTicks.length > 0 && row.timestampSeconds <= workletsTicks.at(-1).timestampSeconds)
+            throw new Error("worklets frame clock timestamps must increase");
+          workletsTicks.push({ timestampSeconds: row.timestampSeconds });
+          continue;
+        }
+        if (row.kind !== "ui-frame" || !Number.isFinite(row.targetTimestampSeconds) || !Number.isFinite(row.timestampSeconds) || !(row.durationSeconds > 0))
+          throw new Error("invalid ui frame clock row");
+        if (ticks.length > 0 && row.targetTimestampSeconds <= ticks.at(-1).targetTimestampSeconds)
+          throw new Error("ui frame clock target timestamps must increase");
+        ticks.push({
+          targetTimestampSeconds: row.targetTimestampSeconds,
+          timestampSeconds: row.timestampSeconds,
+          durationSeconds: row.durationSeconds,
+          clockBridge: row.clockBridge,
+          callbackThread: row.callbackThread,
+          callbackWasMainThread: row.callbackWasMainThread
+        });
+      }
+      if (ticks.length < 2)
+        throw new Error("ui frame clock receipt holds fewer than two ticks");
+      return {
+        domain: "ca-media-time-seconds",
+        source: "cadisplaylink-target-timestamp",
+        sourceReceiptSha256: createHash("sha256").update(bytes).digest("hex"),
+        ticks,
+        workletsTicks
+      };
+    }
+    module2.exports.nativeUIFrameClockReceipt = nativeUIFrameClockReceipt;
+    function pairedNativeWorkletFrameClock(root, lifecycle, seed = "ui-frame-after-delivered-touch-up") {
+      const { boundText } = require_attempt_events();
+      if (!lifecycle || typeof lifecycle !== "object" || Array.isArray(lifecycle))
+        throw new Error("paired worklets clock needs a retained native lifecycle");
+      const receipt = lifecycle.uiFrameClock;
+      if (!receipt)
+        throw new Error("paired worklets clock needs a retained native UI clock receipt");
+      const inputReceipt = lifecycle.deliveredUIKitInput;
+      if (!inputReceipt)
+        throw new Error("paired worklets clock needs a delivered UIKit touch-up witness");
+      const clock = nativeUIFrameClockReceipt(
+        Buffer.from(
+          boundText(
+            root,
+            receipt.sourceReceipt,
+            receipt.sourceReceiptSha256,
+            "native UI clock receipt"
+          )
+        )
+      );
+      const input = nativeUIKitInputReceipt(
+        Buffer.from(
+          boundText(
+            root,
+            inputReceipt.sourceReceipt,
+            inputReceipt.sourceReceiptSha256,
+            "delivered UIKit input receipt"
+          )
+        )
+      );
+      if (seed === "delivered-touch-drag") {
+        const down = input.events[0];
+        const up2 = input.events.at(-1);
+        if (input.status !== "witnessed" || down?.phase !== 0 || up2?.phase !== 3 || !input.events.slice(1, -1).every((event) => event.phase === 1) || input.events.length < 3 || input.events.some(
+          (event, index) => index > 0 && (event.deliveredAtSeconds < input.events[index - 1].deliveredAtSeconds || event.touchTimestampSeconds < input.events[index - 1].touchTimestampSeconds)
+        ))
+          throw new Error(
+            "paired drag needs one ordered delivered UIKit down/moves/up sequence"
+          );
+        if (!clock.ticks.some((tick2) => tick2.timestampSeconds < down.deliveredAtSeconds) || !clock.ticks.some((tick2) => tick2.timestampSeconds > up2.deliveredAtSeconds))
+          throw new Error("native UI clock does not bracket the delivered drag");
+        return {
+          provenance: {
+            sourceReceipt: receipt.sourceReceipt,
+            sourceReceiptSha256: receipt.sourceReceiptSha256,
+            inputReceipt: inputReceipt.sourceReceipt,
+            inputReceiptSha256: inputReceipt.sourceReceiptSha256,
+            alignment: "delivered-touch-drag",
+            stageOffsetBasis: "declared-from-delivered-down",
+            deliveredTouchDownSeconds: down.deliveredAtSeconds
+          },
+          hold: {
+            x: down.x,
+            y: down.y,
+            release: { x: up2.x, y: up2.y },
+            durationMs: (up2.deliveredAtSeconds - down.deliveredAtSeconds) * 1e3,
+            eventDurationMs: (up2.touchTimestampSeconds - down.touchTimestampSeconds) * 1e3,
+            moves: input.events.slice(1, -1).map((event) => ({
+              x: event.x,
+              y: event.y,
+              afterMs: (event.deliveredAtSeconds - down.deliveredAtSeconds) * 1e3,
+              eventAfterMs: (event.touchTimestampSeconds - down.touchTimestampSeconds) * 1e3
+            }))
+          }
+        };
+      }
+      const up = input.events.find((event) => event.phase === 3);
+      if (input.status !== "witnessed" || !up)
+        throw new Error("paired worklets clock needs a delivered UIKit touch-up witness");
+      const startIndex = clock.ticks.findIndex(
+        (tick2) => tick2.timestampSeconds > up.deliveredAtSeconds
+      );
+      if (startIndex < 1)
+        throw new Error("native UI clock does not bracket delivered touch-up");
+      const timestampsSeconds = clock.ticks.slice(startIndex - 1).map((tick2) => tick2.targetTimestampSeconds);
+      return {
+        provenance: {
+          sourceReceipt: receipt.sourceReceipt,
+          sourceReceiptSha256: receipt.sourceReceiptSha256,
+          inputReceipt: inputReceipt.sourceReceipt,
+          inputReceiptSha256: inputReceipt.sourceReceiptSha256,
+          deliveredTouchUpSeconds: up.deliveredAtSeconds,
+          startIndex,
+          alignment: "inferred-next-ui-frame-after-delivered-touch-up",
+          frameCount: timestampsSeconds.length - 1
+        },
+        // the trigger reads the previous frame; the first delivery reads startIndex.
+        timestampsSeconds
+      };
+    }
+    module2.exports.pairedNativeWorkletFrameClock = pairedNativeWorkletFrameClock;
+    function nativeGradingPlan(sourceRoot, declaration) {
+      const fs3 = require("node:fs"), path5 = require("node:path");
+      const catalogs = [
+        ["packages/peach-conformance/src/cases/catalog.cjs", "CONFORMANCE_CASE_CATALOG"],
+        [
+          "packages/peach-library-conformance/src/cases/catalog.cjs",
+          "LIBRARY_CONFORMANCE_CASE_CATALOG"
+        ]
+      ];
+      let catalog, catalogPath;
+      for (const [relative, key] of catalogs) {
+        const entries = require(path5.join(sourceRoot, relative))[key];
+        const entry = entries.find((item) => item.name === declaration.caseName);
+        const checkpoint = entry?.checkpoints?.find(
+          (item) => item.id === declaration.checkpoint
+        );
+        if (checkpoint) {
+          catalog = checkpoint;
+          catalogPath = relative;
+          break;
+        }
+      }
+      if (!catalog || !Array.isArray(catalog.stages) || JSON.stringify(catalog.stages) !== JSON.stringify(declaration.stages.map((stage) => stage.label)))
+        throw new Error(
+          "native sampled grading plan must include every catalog stage in order"
+        );
+      if (JSON.stringify(catalog.motionCadence ?? null) !== JSON.stringify(declaration.cadence))
+        throw new Error("native sampled grading plan changed the catalog cadence");
+      if (declaration.anchorPlan?.stages?.length !== declaration.stages.length || declaration.stages.some(
+        (stage, index) => declaration.anchorPlan.stages[index].anchorId !== (stage.anchor?.id ?? "transition")
+      ))
+        throw new Error("native sampled grading plan changed a declared stage anchor");
+      if (declaration.stages.some(
+        (stage) => !Number.isFinite(stage.offsetMs) || stage.offsetMs < 0
+      ))
+        throw new Error("native sampled grading plan has invalid stage offsets");
+      return {
+        ...declaration,
+        contract: "continuous-catalog-stage-window-v1",
+        catalogPath,
+        catalogSha256: createHash("sha256").update(fs3.readFileSync(path5.join(sourceRoot, catalogPath))).digest("hex")
+      };
+    }
+    module2.exports.nativeGradingPlan = nativeGradingPlan;
+    function tickValue(value, label = "native sampled recording") {
+      if (typeof value !== "string" || !/^\d+$/.test(value))
+        throw new Error(`${label} has invalid mach ticks`);
+      return BigInt(value);
+    }
+    function nativeResolvedGradingWindow(plan, resolution, frames, markers) {
+      const markerStart = tickValue(markers?.machStart, "native grade-start marker");
+      const markerEnd = tickValue(markers?.machEnd, "native grade-end marker");
+      if (!resolution || !Array.isArray(resolution.stages) || resolution.stages.length !== plan.stages.length || resolution.stages.some(
+        (stage, index) => stage.label !== plan.stages[index].label || stage.offsetMs !== plan.stages[index].offsetMs || stage.anchorId !== plan.anchorPlan.stages[index].anchorId || !Number.isFinite(stage.atSec) || stage.atSec < 0
+      ) || !Number.isFinite(resolution.triggerInVideoSec) || resolution.triggerInVideoSec < 0)
+        throw new Error("native sampled window resolution dropped or changed declared stages");
+      for (const stage of resolution.stages) {
+        const offset = stage.touchOffsetMs ?? stage.offsetMs;
+        const expected = stage.basisSec + frameIndexForOffset2(offset, 1e3 / 60) * (1e3 / 60) / 1e3;
+        if (!Number.isFinite(stage.basisSec) || stage.basisSec < 0 || !Number.isFinite(offset) || offset < 0 || !stage.initialBeforeTrigger && stage.atSec !== expected || stage.anchorId !== "transition" && offset !== stage.offsetMs)
+          throw new Error("native sampled window changed the declared stage timing");
+      }
+      const origin = frames[0]?.consumerArrival;
+      if (!origin || !Number.isSafeInteger(origin.timebaseNumer) || origin.timebaseNumer <= 0 || !Number.isSafeInteger(origin.timebaseDenom) || origin.timebaseDenom <= 0)
+        throw new Error("native sampled window has no source clock");
+      const atTicks = (seconds) => {
+        const nanos = Math.ceil(seconds * 1e9);
+        if (!Number.isSafeInteger(nanos) || nanos < 0)
+          throw new Error("native sampled window exceeds exact source range");
+        return BigInt(origin.machTicks) + (BigInt(nanos) * BigInt(origin.timebaseDenom) + BigInt(origin.timebaseNumer) - 1n) / BigInt(origin.timebaseNumer);
+      };
+      const endSeconds = Math.max(
+        ...resolution.stages.map((stage) => stage.atSec),
+        ...plan.cadence ? [resolution.triggerInVideoSec + 1.9] : []
+      );
+      const firstAnchor = atTicks(
+        Math.min(
+          resolution.triggerInVideoSec,
+          ...resolution.stages.map((stage) => Math.min(stage.atSec, stage.basisSec))
+        )
+      );
+      const start = firstAnchor < markerStart ? firstAnchor : markerStart;
+      const end = atTicks(endSeconds) + 1n;
+      if (start < BigInt(origin.machTicks) || end > markerEnd || end <= start)
+        throw new Error("native recorder does not bracket the complete catalog stage window");
+      return { machStart: String(start), machEnd: String(end) };
+    }
+    module2.exports.nativeResolvedGradingWindow = nativeResolvedGradingWindow;
+    function nativeRefreshBoundaryWindows(ticks, { startSeconds, endSeconds }) {
+      if (!Number.isFinite(startSeconds) || !Number.isFinite(endSeconds) || !(endSeconds > startSeconds))
+        throw new Error("native sampled grading window is empty");
+      const intervals = [], gaps = [];
+      for (const [refresh, tick2] of ticks.entries()) {
+        const start = tick2.timestampSeconds, end = tick2.targetTimestampSeconds;
+        if (!(end > start)) throw new Error("native UI clock has a reversed refresh interval");
+        if (end > startSeconds && start < endSeconds) intervals.push({ refresh, start, end });
+        const next = ticks[refresh + 1];
+        if (!next) continue;
+        const rounding = 8 * Number.EPSILON * Math.max(1, Math.abs(end), Math.abs(next.timestampSeconds));
+        if (Math.abs(end - next.timestampSeconds) <= rounding) continue;
+        const gapStart = Math.min(end, next.timestampSeconds);
+        const gapEnd = Math.max(end, next.timestampSeconds);
+        gaps.push({
+          afterRefresh: refresh,
+          start: gapStart,
+          end: gapEnd,
+          intersectsGrading: gapEnd > startSeconds && gapStart < endSeconds
+        });
+      }
+      return {
+        intervals,
+        gaps,
+        bracketed: intervals.length > 0 && intervals[0].start <= startSeconds && intervals.at(-1).end >= endSeconds
+      };
+    }
+    module2.exports.nativeRefreshBoundaryWindows = nativeRefreshBoundaryWindows;
+    function nativeRefreshSamples({
+      frames,
+      reads: observations,
+      clockBytes,
+      finalFrames,
+      finalSurfaceStatus = "settled",
+      grading
+    }) {
+      const clock = nativeUIFrameClockReceipt(clockBytes);
+      const movingFinalSurface = finalSurfaceStatus === "moving" && finalFrames.length === 0;
+      if (!frames.length || !observations.length || !movingFinalSurface && finalFrames.length < 3)
+        throw new Error("native sampled recording has no observed stable final surface");
+      const origin = frames[0].consumerArrival;
+      if (origin?.domain !== "host-mach-absolute-time" || !/^[0-9a-f-]{36}$/i.test(origin.bootSessionUUID ?? "") || !Number.isSafeInteger(origin.timebaseNumer) || origin.timebaseNumer <= 0 || !Number.isSafeInteger(origin.timebaseDenom) || origin.timebaseDenom <= 0)
+        throw new Error("native sampled recording has no authenticated host clock");
+      const secondsPerTick = origin.timebaseNumer / origin.timebaseDenom / 1e9;
+      const bridgeOrigin = tickValue(clock.ticks[0].clockBridge?.machBefore);
+      const elapsed = (value) => {
+        const ticks = tickValue(value) - bridgeOrigin;
+        if (ticks < -BigInt(Number.MAX_SAFE_INTEGER) || ticks > BigInt(Number.MAX_SAFE_INTEGER))
+          throw new Error("native clock bridge exceeds exact mach range");
+        return Number(ticks) * secondsPerTick;
+      };
+      let lowerOffset = -Infinity;
+      let upperOffset = Infinity;
+      for (const tick2 of clock.ticks) {
+        if (tick2.callbackThread !== "dedicated-user-interactive-run-loop" || tick2.callbackWasMainThread !== false)
+          throw new Error(
+            "native UI clock callback did not run on its independent recorder thread"
+          );
+        const bridge = tick2.clockBridge;
+        if (bridge?.bootSessionUUID !== origin.bootSessionUUID || bridge.timebaseNumer !== origin.timebaseNumer || bridge.timebaseDenom !== origin.timebaseDenom || !Number.isFinite(bridge.mediaSeconds))
+          throw new Error("native clock bridge kernel identity or timebase mismatch");
+        const before = elapsed(bridge.machBefore), after = elapsed(bridge.machAfter);
+        if (after < before) throw new Error("native clock bridge has reversed bracket");
+        const rounding = 8 * Number.EPSILON * Math.max(1, Math.abs(bridge.mediaSeconds));
+        lowerOffset = Math.max(lowerOffset, bridge.mediaSeconds - after - rounding);
+        upperOffset = Math.min(upperOffset, bridge.mediaSeconds - before + rounding);
+      }
+      if (lowerOffset > upperOffset) throw new Error("native clock bridge brackets disagree");
+      const sourceFrames = new Map(
+        frames.map((frame, index) => [frame.callbackIndex, { frame, index }])
+      );
+      if (sourceFrames.size !== frames.length)
+        throw new Error("native source callbacks repeat");
+      const preservedEnds = frames.map((frame) => tickValue(frame.readWindow?.machEnd));
+      if (preservedEnds.some((end, index) => index > 0 && end <= preservedEnds[index - 1]))
+        throw new Error("native preserved source copy windows are not increasing");
+      let latestPreserved = -1;
+      let previousEnd = -Infinity;
+      const reads = observations.map((frame) => {
+        const readEnd = tickValue(frame.readWindow?.machEnd);
+        while (latestPreserved + 1 < frames.length && preservedEnds[latestPreserved + 1] <= readEnd)
+          latestPreserved++;
+        const reference = sourceFrames.get(frame.sourceCallbackIndex);
+        if (!reference || reference.index !== latestPreserved || reference.frame.rawPath !== frame.rawPath || reference.frame.rawFramebuffer?.sha256 !== frame.rawFramebuffer?.sha256 || reference.frame.rawFramebuffer?.width !== frame.rawFramebuffer?.width || reference.frame.rawFramebuffer?.height !== frame.rawFramebuffer?.height || reference.frame.rawFramebuffer?.stride !== frame.rawFramebuffer?.stride || reference.frame.rawFramebuffer?.pixelFormat !== frame.rawFramebuffer?.pixelFormat || reference.frame.source?.screenId !== frame.source?.screenId || tickValue(reference.frame.readWindow?.machEnd) > tickValue(frame.readWindow?.machEnd))
+          throw new Error("native sampled read has no matching immutable source pixels");
+        const host = frame.consumerArrival;
+        if (host?.bootSessionUUID !== origin.bootSessionUUID || host.domain !== origin.domain || host.timebaseNumer !== origin.timebaseNumer || host.timebaseDenom !== origin.timebaseDenom || !Number.isSafeInteger(frame.source?.seedBeforeRead) || frame.source.seedBeforeRead !== frame.source.seedAfterRead || frame.source.surfaceSeed !== frame.source.seedBeforeRead || frame.rawFramebuffer?.status !== "preserved" || !/^[a-f0-9]{64}$/.test(frame.rawFramebuffer.sha256))
+          throw new Error("native sampled read is superseded or has a different clock");
+        const start = elapsed(frame.readWindow?.machStart), end = elapsed(frame.readWindow?.machEnd);
+        if (end < start || start < previousEnd || tickValue(frame.readWindow.machStart) < tickValue(host.machTicks))
+          throw new Error("native sampled read has an invalid copy window");
+        previousEnd = end;
+        return {
+          start: start + lowerOffset,
+          end: end + upperOffset,
+          sourceFrameIndex: reference.index,
+          callbackIndex: frame.callbackIndex
+        };
+      });
+      const gradedStart = elapsed(grading?.machStart) + lowerOffset;
+      const gradedEnd = elapsed(grading?.machEnd) + upperOffset;
+      if (!(gradedEnd > gradedStart))
+        throw new Error("native sampled grading window is empty");
+      const boundaries = nativeRefreshBoundaryWindows(clock.ticks, {
+        startSeconds: gradedStart,
+        endSeconds: gradedEnd
+      });
+      const uncovered = boundaries.gaps.find((gap) => gap.intersectsGrading);
+      if (uncovered)
+        throw new Error(
+          `native UI clock has an uncovered refresh after ${uncovered.afterRefresh}`
+        );
+      if (!boundaries.bracketed)
+        throw new Error("native UI clock does not bracket every graded refresh");
+      const samples = [];
+      let cursor = 0;
+      for (const { refresh, start, end } of boundaries.intervals) {
+        while (cursor < reads.length && reads[cursor].start < start) cursor++;
+        if (cursor === reads.length || reads[cursor].end >= end)
+          throw new Error(`native recording has no surface sampled during refresh ${refresh}`);
+        samples.push({
+          refresh,
+          sourceFrameIndex: reads[cursor].sourceFrameIndex,
+          observationCallbackIndex: reads[cursor].callbackIndex,
+          evidence: `surface sampled during refresh ${refresh}`
+        });
+      }
+      const final = observations.at(-1);
+      let previousFinalEnd = tickValue(final.readWindow.machEnd);
+      for (const settled of finalFrames) {
+        const host = settled.consumerArrival;
+        const source = settled.source, raw = settled.rawFramebuffer;
+        if (host?.bootSessionUUID !== origin.bootSessionUUID || host.domain !== origin.domain || host.timebaseNumer !== origin.timebaseNumer || host.timebaseDenom !== origin.timebaseDenom || !Number.isSafeInteger(source?.seedBeforeRead) || source.surfaceSeed !== source.seedBeforeRead || source.seedBeforeRead !== source.seedAfterRead || raw?.status !== "preserved" || raw.sha256 !== final.rawFramebuffer.sha256 || raw.width !== final.rawFramebuffer.width || raw.height !== final.rawFramebuffer.height || raw.stride !== final.rawFramebuffer.stride || raw.pixelFormat !== final.rawFramebuffer.pixelFormat || source.screenId !== final.source.screenId || tickValue(settled.readWindow?.machStart) <= previousFinalEnd || tickValue(settled.readWindow?.machEnd) < tickValue(settled.readWindow?.machStart))
+          throw new Error(
+            "native recording final surface is unobserved or mismatches stable post-settle reads"
+          );
+        previousFinalEnd = tickValue(settled.readWindow.machEnd);
+      }
+      return {
+        contract: "per-refresh-sampled-surface-v1",
+        samples,
+        displayedWrite: "unknown: may differ from sampled write within refresh",
+        limits: {
+          clockDiscontinuities: boundaries.gaps,
+          ...movingFinalSurface ? { finalSurface: "moving" } : {}
+        },
+        bridge: { bootSessionUUID: origin.bootSessionUUID, lowerOffset, upperOffset }
+      };
+    }
+    module2.exports.nativeRefreshSamples = nativeRefreshSamples;
+    function authenticateNativeRefreshSamples(root, sourceRoot, lifecycle) {
+      const fs3 = require("node:fs");
+      const path5 = require("node:path");
+      const { boundText } = require_attempt_events();
+      const native = lifecycle.nativeFramebuffer;
+      if (!native || native.exitCode !== 0 || native.failure || native.sourceSha256 !== createHash("sha256").update(
+        fs3.readFileSync(
+          path5.join(sourceRoot, "scripts/debug/native-ios-frame-consumer.m")
+        )
+      ).digest("hex"))
+        throw new Error("native sampled recording has no source-matched consumer");
+      const parse2 = (text) => text.split("\n").filter(Boolean).map(JSON.parse);
+      const frames = parse2(
+        boundText(root, native.receipt, native.receiptSha256, "native sampled reads")
+      );
+      const observations = parse2(
+        boundText(root, native.reads, native.readsSha256, "native sampled copy windows")
+      );
+      const clock = lifecycle.uiFrameClock;
+      const clockBytes = Buffer.from(
+        boundText(
+          root,
+          clock?.sourceReceipt,
+          clock?.sourceReceiptSha256,
+          "native sampled UI clock and bridge"
+        )
+      );
+      const finalSurfaceStatus = lifecycle.finalFrameProof?.status;
+      if (!Array.isArray(native.finalReads) || native.finalReads.length < 3 && !(finalSurfaceStatus === "moving" && native.finalReads.length === 0))
+        throw new Error("native sampled recording has no stable post-settle reads");
+      if (new Set(native.finalReads.map((receipt) => receipt.path)).size !== native.finalReads.length)
+        throw new Error("native sampled end-state receipts repeat an observation");
+      const finalFrames = native.finalReads.map((receipt) => {
+        const rows = parse2(
+          boundText(root, receipt.path, receipt.sha256, "native sampled end state")
+        );
+        if (!rows.length) throw new Error("native sampled end state is unobserved");
+        return rows.at(-1);
+      });
+      const plan = JSON.parse(
+        boundText(
+          root,
+          native.gradingPlan,
+          native.gradingPlanSha256,
+          "native sampled pre-capture stage plan"
+        )
+      );
+      const verifiedPlan = nativeGradingPlan(sourceRoot, plan);
+      const { catalogSha256: capturedCatalogSha256, ...capturedCheckpoint } = plan;
+      const { catalogSha256: currentCatalogSha256, ...verifiedCheckpoint } = verifiedPlan;
+      if (!/^[a-f0-9]{64}$/.test(capturedCatalogSha256 ?? "") || !/^[a-f0-9]{64}$/.test(currentCatalogSha256) || JSON.stringify(verifiedCheckpoint) !== JSON.stringify(capturedCheckpoint) || observations.some((row) => row.gradingPlanSha256 !== native.gradingPlanSha256) || frames.some((row) => row.gradingPlanSha256 !== native.gradingPlanSha256))
+        throw new Error("native sampled stage plan was not bound before acquisition");
+      const resolution = JSON.parse(
+        boundText(
+          root,
+          native.windowResolution,
+          native.windowResolutionSha256,
+          "native sampled window resolution"
+        )
+      );
+      const markers = JSON.parse(
+        boundText(
+          root,
+          native.gradingMarkers,
+          native.gradingMarkersSha256,
+          "native sampled trigger markers"
+        )
+      );
+      const grading = nativeResolvedGradingWindow(plan, resolution, frames, markers);
+      return nativeRefreshSamples({
+        frames,
+        reads: observations,
+        clockBytes,
+        finalFrames,
+        finalSurfaceStatus,
+        grading
+      });
+    }
+    module2.exports.authenticateNativeRefreshSamples = authenticateNativeRefreshSamples;
     async function encodeNativeFramebufferMovie(rawDir, videoPath) {
       const fs3 = require("node:fs");
       const path5 = require("node:path");
@@ -1979,6 +2569,13 @@ var require_attempt_events = __commonJS({
         throw new Error("cadence evidence path escapes its root");
       return resolved;
     }
+    function boundText(root, relative, sha256, label) {
+      const bytes = fs3.readFileSync(proofBoundPath(root, relative));
+      if (proofByteHash(bytes) !== sha256)
+        throw new Error(`${label} does not match its recorded hash`);
+      return bytes.toString("utf8");
+    }
+    module2.exports.boundText = boundText;
     function authenticateDiscreteFrameAsset(root, declaration, calibrate = false) {
       const cadence = parseDiscreteFrameCadence(declaration);
       const fixture = fs3.readFileSync(proofBoundPath(root, cadence.asset.fixturePath));
@@ -2179,6 +2776,10 @@ var require_attempt_events = __commonJS({
       };
     }
     function authenticateNativeCadenceCensus(root, sourceRoot, life, decoded) {
+      const {
+        authenticateNativeRefreshSamples
+      } = require_native_frame_receipt();
+      authenticateNativeRefreshSamples(root, sourceRoot, life);
       const native = life.nativeFramebuffer;
       if (!native || native.exitCode !== 0 || native.failure || native.sourceSha256 !== proofByteHash(
         fs3.readFileSync(
@@ -2186,19 +2787,54 @@ var require_attempt_events = __commonJS({
         )
       ))
         throw new Error("native cadence has no source-matched framebuffer consumer");
-      const frames = fs3.readFileSync(proofBoundPath(root, native.receipt), "utf8").trim().split("\n").map(JSON.parse);
-      const media = fs3.readFileSync(proofBoundPath(root, native.mediaFrames), "utf8").trim().split("\n").map(JSON.parse);
+      const frames = boundText(
+        root,
+        native.receipt,
+        native.receiptSha256,
+        "native cadence source receipt"
+      ).trim().split("\n").map(JSON.parse);
+      const media = boundText(
+        root,
+        native.mediaFrames,
+        native.mediaFramesSha256,
+        "native cadence sampled surface census"
+      ).trim().split("\n").map(JSON.parse);
       if (frames.length !== decoded.observations.length || media.length !== frames.length)
-        throw new Error("native cadence acquisition and presentation census differ");
+        throw new Error("native cadence acquisition and sampled surface census differ");
       const {
         decodeNativeFramebuffer,
         requireNativeRawFrame
       } = require_native_frame_receipt();
       const rawRoot = path5.dirname(proofBoundPath(root, native.receipt));
+      const superseded = new Set(
+        boundText(
+          root,
+          native.superseded,
+          native.supersededSha256,
+          "native cadence superseded receipt"
+        ).split("\n").filter(Boolean).map((line) => {
+          const row = JSON.parse(line);
+          if (!Number.isSafeInteger(row.callbackIndex) || row.seedBeforeRead === row.seedAfterRead)
+            throw new Error("native superseded receipt is not an overwritten read");
+          return row.callbackIndex;
+        })
+      );
+      const reads = boundText(
+        root,
+        native.reads,
+        native.readsSha256,
+        "native cadence observations"
+      ).split("\n").filter(Boolean).map(JSON.parse);
+      let expectedCallback = 0;
+      for (const read of reads) {
+        while (superseded.delete(expectedCallback)) expectedCallback++;
+        if (read.callbackIndex !== expectedCallback++)
+          throw new Error("native cadence observations have invalid callback order");
+      }
       const origin = frames[0].consumerArrival;
       for (const [index, frame] of frames.entries()) {
         const clock = frame.consumerArrival;
-        if (frame.callbackIndex !== index || media[index].sourceFrameIndex !== index || !clock || clock.domain !== "host-mach-absolute-time" || clock.domain !== origin.domain || clock.timebaseNumer !== origin.timebaseNumer || clock.timebaseDenom !== origin.timebaseDenom || !Number.isSafeInteger(clock.timebaseNumer) || clock.timebaseNumer <= 0 || !Number.isSafeInteger(clock.timebaseDenom) || clock.timebaseDenom <= 0)
+        if (media[index].sourceFrameIndex !== index || !clock || clock.domain !== "host-mach-absolute-time" || clock.domain !== origin.domain || clock.timebaseNumer !== origin.timebaseNumer || clock.timebaseDenom !== origin.timebaseDenom || !Number.isSafeInteger(clock.timebaseNumer) || clock.timebaseNumer <= 0 || !Number.isSafeInteger(clock.timebaseDenom) || clock.timebaseDenom <= 0)
           throw new Error("native cadence source census has invalid clock or order");
         const pts = (BigInt(clock.machTicks) - BigInt(origin.machTicks)) * BigInt(clock.timebaseNumer) / BigInt(clock.timebaseDenom);
         if (pts < 0n || pts !== BigInt(media[index].ptsNanoseconds) || Math.abs(Number(pts) / 1e6 - decoded.observations[index].atMs) > 1e-3)
@@ -2211,6 +2847,9 @@ var require_attempt_events = __commonJS({
           )
         );
       }
+      while (superseded.delete(expectedCallback)) expectedCallback++;
+      if (superseded.size)
+        throw new Error("native superseded receipts fall outside the callback order");
     }
     function readDiscreteFrameReceipt(root, sourceRoot, reference, expected) {
       if (expected.calibration !== true) assertNormalProofAttempt(root);
@@ -2444,10 +3083,41 @@ var require_attempt_events = __commonJS({
           const life = JSON.parse(
             fs3.readFileSync(proofBoundPath(root, receipt.lifecycle.path), "utf8")
           );
+          for (const [label, auxiliary] of [
+            ["ui frame clock", life.uiFrameClock],
+            ["delivered input", life.deliveredUIKitInput]
+          ]) {
+            if (!auxiliary) continue;
+            const bytes = fs3.readFileSync(proofBoundPath(root, auxiliary.sourceReceipt));
+            if (proofByteHash(bytes) !== auxiliary.sourceReceiptSha256)
+              throw new Error(`native ${label} receipt does not match its recorded hash`);
+            paths.add(auxiliary.sourceReceipt);
+          }
           const native = life.nativeFramebuffer;
           if (native) {
             paths.add(native.receipt);
+            paths.add(native.superseded);
             paths.add(native.mediaFrames);
+            paths.add(native.gradingMarkers);
+            paths.add(native.gradingPlan);
+            paths.add(native.windowResolution);
+            paths.add(native.reads);
+            for (const receipt2 of native.finalReads) {
+              const text = boundText(
+                root,
+                receipt2.path,
+                receipt2.sha256,
+                "native sampled end state"
+              );
+              paths.add(receipt2.path);
+              for (const row of text.split("\n").filter(Boolean).map(JSON.parse)) {
+                const file = proofBoundPath(
+                  path5.dirname(proofBoundPath(root, receipt2.path)),
+                  row.rawPath
+                );
+                paths.add(path5.relative(root, file).split(path5.sep).join("/"));
+              }
+            }
             const rows = fs3.readFileSync(proofBoundPath(root, native.receipt), "utf8").trim().split("\n").map(JSON.parse);
             for (const row of rows) {
               const file = proofBoundPath(
@@ -6348,6 +7018,11 @@ function sameNativeAccessibilityShape(a, b, bounds) {
   return true;
 }
 
+// src/is-record.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // cli/commands/inspect/core.ts
 function layoutBoundFontFamily(style) {
   const raw = typeof style === "object" && style !== null ? style.fontFamily : void 0;
@@ -7362,9 +8037,12 @@ var AUTOMATION_SIM_IDLE_REAP_TTL_MS = 5 * 6e4;
 // src/home-paths.ts
 var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
 
-// ../peach-engine/src/tenant-bundle-mode.ts
+// ../peach-engine/src/preview/bundle-layout.ts
 var import_metro_production_bundle = require("peachsim/metro-production-bundle");
 
+// ../peach-engine/src/tenant-bundle-mode.ts
+var import_metro_production_bundle2 = require("peachsim/metro-production-bundle");
+
 // ../peach-engine/src/tenant-runtime-environment.ts
 function readBrowserLocation() {
   try {
@@ -7843,7 +8521,7 @@ var PEACH_UPSTREAM_MODULES = {
 };
 
 // ../peach-engine/src/metro-fingerprint.ts
-var import_metro_production_bundle2 = require("peachsim/metro-production-bundle");
+var import_metro_production_bundle3 = require("peachsim/metro-production-bundle");
 var import_react_native_host_modules = require("peachsim/react-native-host-modules");
 
 // src/cloud-contract.ts
@@ -10636,6 +11314,10 @@ function setPauseAwareTimeout(fn, budgetMs, hostPid) {
   }
   return () => {
     timers.delete(timer);
+    if (timers.size === 0 && poll) {
+      clearInterval(poll);
+      poll = void 0;
+    }
   };
 }
 
@@ -10674,7 +11356,10 @@ var BRIDGE_VALUE_FLAGS_TABLE = [
   {
     names: ["--timeout"],
     apply: (state, value) => {
-      if (value !== void 0) state.commandTimeoutMs = Number(value);
+      if (value !== void 0) {
+        state.commandTimeoutMs = Number(value);
+        state.explicitTimeout = true;
+      }
     }
   },
   {
@@ -10814,7 +11499,7 @@ function createBridge(wsPort, opts = {}) {
   return {
     plane: "local",
     async send(cmd, callOpts) {
-      const effectiveTimeoutMs = callOpts?.timeoutMs ?? commandTimeoutMs;
+      const effectiveTimeoutMs = callOpts?.timeoutMs ?? (opts.explicitTimeout ? commandTimeoutMs : callOpts?.defaultTimeoutMs) ?? commandTimeoutMs;
       const sendOnce = async (defaultSimId, cmdOverride) => {
         await ready;
         if (terminalError) throw terminalError;
@@ -10827,11 +11512,7 @@ function createBridge(wsPort, opts = {}) {
           const clearTimeoutFn = setPauseAwareTimeout(
             () => {
               pending.delete(id);
-              reject(
-                new Error(
-                  `command timed out after ${Math.round(effectiveTimeoutMs / 1e3)}s`
-                )
-              );
+              reject(new Error(`command timed out after ${effectiveTimeoutMs / 1e3}s`));
             },
             effectiveTimeoutMs,
             lineageBySimId.get(payload.simId)?.hostPid
@@ -11064,25 +11745,8 @@ function usesDirectLookup(matcher) {
   return matcher.regexFlags === void 0 && matcher.index === void 0 && matcher.type !== "text";
 }
 
-// ../peach-engine/src/platform/adapter.ts
-var IOS_ADAPTER = Object.freeze({
-  id: "ios",
-  displayName: "iOS",
-  isIOS: true,
-  isAndroid: false,
-  select: (registry) => registry.ios
-});
-var ANDROID_ADAPTER = Object.freeze({
-  id: "android",
-  displayName: "Android",
-  isIOS: false,
-  isAndroid: true,
-  select: (registry) => registry.android
-});
-var RUNTIME_PLATFORM_ADAPTERS = Object.freeze({
-  ios: IOS_ADAPTER,
-  android: ANDROID_ADAPTER
-});
+// ../peach-engine/src/settings/device-spec-bus.ts
+init_adapter();
 
 // ../peach-engine/src/settings/dynamic-type.ts
 function textMetrics(fontSize, lineHeight, leading, ascent) {
@@ -12097,8 +12761,94 @@ async function dispatchTwoFingerGesture(page, startA, startB, endA, endB, option
   await page.waitForTimeout(250);
 }
 
+// ../contrast-runtime-delivery/src/version.ts
+function isValidRuntimeVersion(value) {
+  return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);
+}
+
+// src/nativeViewSourceContract.ts
+function isNativeViewSource(value) {
+  if (!isRecord(value)) return false;
+  if (value.type === "placeholder")
+    return (value.uri === void 0 || typeof value.uri === "string" && value.uri.length > 0) && (value.color === void 0 || typeof value.color === "string");
+  if (value.type === "web") {
+    if (typeof value.uri !== "string") return false;
+    try {
+      const url = new URL(value.uri);
+      return url.protocol === "http:" || url.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }
+  return value.type === "video" && typeof value.uri === "string" && value.uri.length > 0 && ["paused", "loop", "muted"].every(
+    (key) => value[key] === void 0 || typeof value[key] === "boolean"
+  ) && (value.currentTime === void 0 || typeof value.currentTime === "number" && Number.isFinite(value.currentTime) && value.currentTime >= 0) && (value.resizeMode === void 0 || value.resizeMode === "contain" || value.resizeMode === "cover" || value.resizeMode === "stretch");
+}
+
+// src/config.ts
+function readNativeRenderer2(value) {
+  if (value === void 0) return void 0;
+  if (value === "paper" || value === "fabric") return value;
+  throw new Error("nativeRenderer must be paper or fabric");
+}
+function isPackageStubs(value) {
+  if (value === "noop") return true;
+  if (!isRecord(value)) return false;
+  return (value.modules === void 0 || isRecord(value.modules) && Object.values(value.modules).every(
+    (stub) => typeof stub === "string" && stub.length > 0
+  )) && (value.views === void 0 || isRecord(value.views) && Object.values(value.views).every(
+    (stub) => typeof stub === "string" && stub.length > 0 || isNativeViewSource(stub)
+  ));
+}
+var PEACH_CONFIG_QUERY_PARAM = "peachConfig";
+function isPeachConfig(value) {
+  if (!isRecord(value)) return false;
+  return (value.nativeRenderer === void 0 || value.nativeRenderer === "paper" || value.nativeRenderer === "fabric") && (value.mapKit === void 0 || isRecord(value.mapKit) && typeof value.mapKit.token === "string" && value.mapKit.token.length > 0 && value.mapKit.token === value.mapKit.token.trim()) && (value.runtimeVersion === void 0 || typeof value.runtimeVersion === "string" && value.runtimeVersion === value.runtimeVersion.trim() && isValidRuntimeVersion(value.runtimeVersion)) && [
+    "modules",
+    "packages",
+    "turboModules",
+    "nativeModules",
+    "nativeViews",
+    "env",
+    "network",
+    "settings",
+    "initialProps",
+    "initialState"
+  ].every((key) => value[key] === void 0 || isRecord(value[key])) && (value.packages === void 0 || isRecord(value.packages) && Object.values(value.packages).every(isPackageStubs)) && (value.nativeViews === void 0 || isRecord(value.nativeViews) && Object.values(value.nativeViews).every(
+    (entry) => entry === "noop" || isNativeViewSource(entry) || isRecord(entry) && typeof entry.file === "string" && entry.file.length > 0
+  ));
+}
+function hasOwnKeys(value) {
+  return !!value && Object.keys(value).length > 0;
+}
+function hasPeachConfig(config) {
+  if (!config) return false;
+  return config.nativeRenderer !== void 0 || config.mapKit !== void 0 || typeof config.runtimeVersion === "string" && config.runtimeVersion.length > 0 || hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.nativeModules) || hasOwnKeys(config.nativeViews) || hasOwnKeys(config.env) || hasOwnKeys(config.network?.remap) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialProps) || hasOwnKeys(config.initialState);
+}
+function readPeachConfigFromSearchParams(searchParams) {
+  const raw = searchParams.get(PEACH_CONFIG_QUERY_PARAM);
+  if (!raw) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[peach] invalid ${PEACH_CONFIG_QUERY_PARAM}: ${message}`);
+    return void 0;
+  }
+  if (isRecord(parsed)) readNativeRenderer2(parsed.nativeRenderer);
+  return isPeachConfig(parsed) && hasPeachConfig(parsed) ? parsed : void 0;
+}
+
 // detox/navigation-lifecycle.ts
 var import_attempt_events = __toESM(require_attempt_events(), 1);
+var developerToken = readPeachConfigFromSearchParams(
+  new URL(process.env.PEACH_URL || "http://localhost").searchParams
+)?.mapKit?.token;
+function redactDiagnosticText(text) {
+  const withoutConfig = text.replace(/([?&]peachConfig=)[^&\s"'<>]+/g, "$1[redacted]");
+  return developerToken ? withoutConfig.replaceAll(developerToken, "[redacted]") : withoutConfig;
+}
 var DIAGNOSTIC_LIMIT = 40;
 var pageDiagnostics = /* @__PURE__ */ new WeakMap();
 var activeNavigations = /* @__PURE__ */ new WeakMap();
@@ -12111,6 +12861,21 @@ function persistDiagnostic(diagnostic) {
   (0, import_attempt_events.writeAttemptEvent)(diagnostic);
 }
 function recordPageDiagnostic(page, diagnostic, persist = false) {
+  if ("url" in diagnostic) diagnostic.url = redactDiagnosticText(diagnostic.url);
+  if ("navigationUrl" in diagnostic)
+    diagnostic.navigationUrl = redactDiagnosticText(diagnostic.navigationUrl);
+  if ("message" in diagnostic)
+    diagnostic.message = redactDiagnosticText(diagnostic.message);
+  if ("errorText" in diagnostic && diagnostic.errorText)
+    diagnostic.errorText = redactDiagnosticText(diagnostic.errorText);
+  if ("pageState" in diagnostic && diagnostic.pageState) {
+    if ("url" in diagnostic.pageState)
+      diagnostic.pageState.url = redactDiagnosticText(diagnostic.pageState.url);
+    if ("evaluateError" in diagnostic.pageState)
+      diagnostic.pageState.evaluateError = redactDiagnosticText(
+        diagnostic.pageState.evaluateError
+      );
+  }
   const entries = pageDiagnostics.get(page);
   if (!entries) return;
   entries.push(diagnostic);
@@ -12217,7 +12982,7 @@ function attachPageDiagnostics(page) {
 }
 async function readSootsimPageState(page) {
   try {
-    return await page.evaluate(() => {
+    const state = await page.evaluate(() => {
       const bootMarks = Reflect.get(window, "__sootsimBootMarks");
       return {
         bodyText: document.body?.innerText?.slice(0, 500) ?? "",
@@ -12234,6 +12999,8 @@ async function readSootsimPageState(page) {
         url: window.location.href
       };
     });
+    state.url = redactDiagnosticText(state.url);
+    return state;
   } catch (error) {
     return {
       evaluateError: error instanceof Error ? error.message : String(error)
@@ -12258,14 +13025,14 @@ async function describeSootsimBridgeFailure(page, cause, summary = "timed out wa
       `page: ${JSON.stringify(state)}`,
       `recent page diagnostics:
 ${JSON.stringify(getSootsimNavigationDiagnostics(page))}`
-    ].join("\n")
+    ].map(redactDiagnosticText).join("\n")
   );
 }
 async function navigateSootsimPage(page, url, identity) {
   attachPageDiagnostics(page);
   const navigation = {
     ...identity,
-    navigationUrl: url,
+    navigationUrl: redactDiagnosticText(url),
     navigationId: ++nextNavigationIdentity
   };
   activeNavigations.set(page, navigation);
@@ -12318,12 +13085,13 @@ function visibleFraction(node) {
 function isNodeVisible(node) {
   return visibleFraction(node) >= DEFAULT_VISIBILITY_THRESHOLD;
 }
-function focusIsWithin(focused, nodeId) {
-  return focused.nodeId === nodeId || focused.ancestorNodeIds.includes(nodeId);
+function focusIsWithin(focused, node) {
+  const nativeNodeId = node.nativeTag ?? node.nodeId;
+  return focused.nodeId === nativeNodeId || focused.ancestorNodeIds.includes(nativeNodeId);
 }
 async function isTextInputNodeFocused(node, page) {
   const focused = await page.evaluate(async () => window.__sootsimTest.getFocusedNode());
-  return focused !== null && focusIsWithin(focused, node.nodeId);
+  return focused !== null && focusIsWithin(focused, node);
 }
 async function isNodeFocused(node, page) {
   if (node.isTextInput) return isTextInputNodeFocused(node, page);
@@ -12766,6 +13534,7 @@ var by = {
 // detox/index.ts
 var import_motion_change = __toESM(require_motion_change(), 1);
 var import_proof_frame = __toESM(require_proof_frame(), 1);
+var WORKLET_FRAME_TRACE_LIMIT = 16384;
 var BASE_URL = process.env.PEACH_URL || "http://localhost:5173";
 var SCREENSHOT_DIR = process.env.PEACH_SCREENSHOT_DIR || path4.join(process.cwd(), "test", "detox-driver", "screenshots", String(process.pid));
 var _browser = null;
@@ -12773,6 +13542,7 @@ var _browserLaunch = null;
 var _browserLaunchAbort = null;
 var _reapBrowserNow = null;
 var _context = null;
+var _appStorageState;
 var _page = null;
 var _synchronizationEnabled = false;
 var _proofFrameObservationActive = false;
@@ -12968,14 +13738,17 @@ async function waitForSootsimWorkletsIdle(page, timeout = 3e3) {
       let readStartedAt = null;
       let tenantAtRead = window.__sootsimRenderHost;
       let shellAtRead = window.SootSim?.bridges?.shellHost;
+      let peerProgress = null;
       let deadlineTimerLateMs = null;
       while (Date.now() < deadline) {
         readStartedAt = Date.now();
         tenantAtRead = window.__sootsimRenderHost;
         shellAtRead = window.SootSim?.bridges?.shellHost;
         let timer;
+        const peerRead = getPeerStats(false);
+        peerProgress = peerRead && "peachPeerProgress" in peerRead ? peerRead.peachPeerProgress ?? null : null;
         const stats = await Promise.race([
-          getPeerStats(false),
+          peerRead,
           new Promise((resolve3) => {
             timer = setTimeout(
               () => {
@@ -13012,6 +13785,7 @@ async function waitForSootsimWorkletsIdle(page, timeout = 3e3) {
         outstandingRead: readStartedAt === null ? null : {
           startedAtMs: readStartedAt - start,
           elapsedMs: Date.now() - readStartedAt,
+          peerProgress: peerProgress ? { ...peerProgress } : null,
           testBridgeChanged: window.__sootsimTest !== testBridge,
           tenant: {
             presentAtRequest: !!tenantAtRead,
@@ -13037,8 +13811,12 @@ async function waitForSootsimWorkletsIdle(page, timeout = 3e3) {
   );
   if (!result?.settled) {
     const pending = result?.pending ?? "no peer stats reply";
-    throw new Error(
-      `sootsim worklet runtime did not settle after ${result?.elapsed ?? timeout}ms (pending=${pending}; observation=${JSON.stringify(result?.observation)})`
+    throw await describeSootsimBridgeFailure(
+      page,
+      new Error(
+        `sootsim worklet runtime did not settle after ${result?.elapsed ?? timeout}ms (pending=${pending}; observation=${JSON.stringify(result?.observation)})`
+      ),
+      "sootsim worklet runtime did not settle"
     );
   }
 }
@@ -13092,7 +13870,8 @@ async function quiesceContextMedia(context) {
     if (timer !== void 0) clearTimeout(timer);
   }
 }
-async function closeContext() {
+async function closeContext(preserveStorage) {
+  if (!preserveStorage) _appStorageState = void 0;
   if (_browserCompromised) {
     throw new Error(`sootsim browser is compromised: ${_browserCompromised}`);
   }
@@ -13100,6 +13879,13 @@ async function closeContext() {
   const context = _context;
   const closingContextId = contextIdentity;
   try {
+    if (preserveStorage) {
+      _appStorageState = await withLifecycleTimeout(
+        "context.storageState()",
+        closingContextId,
+        () => context.storageState({ indexedDB: true })
+      );
+    }
     await quiesceContextMedia(context);
     await withLifecycleTimeout("context.close()", closingContextId, () => context.close());
     _context = null;
@@ -13113,7 +13899,8 @@ async function closeContext() {
     throw error;
   }
 }
-async function closeBrowser() {
+async function closeBrowser(preserveStorage) {
+  if (!preserveStorage) _appStorageState = void 0;
   if (!_browser) return;
   const browser = _browser;
   const reapBrowserNow = _reapBrowserNow;
@@ -13122,7 +13909,7 @@ async function closeBrowser() {
   browserIdentity = 0;
   let closeError = null;
   try {
-    await closeContext();
+    await closeContext(preserveStorage);
   } catch (error) {
     closeError = error instanceof Error ? error : new Error(String(error));
   }
@@ -13358,7 +14145,7 @@ async function focusElementForTextEntry(el) {
   await el.tap();
   await pollUntil(
     () => page.evaluate(async () => window.__sootsimTest.getFocusedNode()),
-    (focused) => focused !== null && focusIsWithin(focused, node.nodeId),
+    (focused) => focused !== null && focusIsWithin(focused, node),
     {
       timeoutMs: 5e3,
       label: `SootSim text input ${node.nodeId} to focus`
@@ -13747,10 +14534,11 @@ function createSootSimElement(matcher) {
       }
     },
     async swipe(direction, speed = "fast", percentage = 0.75, normalizedStartingPointX = 0.5, normalizedStartingPointY = 0.5) {
+      const page = getPage();
+      if (_synchronizationEnabled) await waitForSootsimIdle2(page, 3e3, false, 0);
       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;
@@ -14127,10 +14915,11 @@ var device = {
       }
     }
     if (!_page || newInstance || opts?.delete || opts?.recordVideoDir) {
-      await closeContext();
+      await closeContext(!opts?.delete);
       const contextOpts = {
         hasTouch: true,
-        viewport: { width: 500, height: 900 }
+        viewport: { width: 500, height: 900 },
+        storageState: _appStorageState
       };
       if (opts?.recordVideoDir) {
         fs2.mkdirSync(opts.recordVideoDir, { recursive: true });
@@ -14235,11 +15024,12 @@ var device = {
     await waitForSootsimWorkletsIdle(page, 3e3);
   },
   async terminateApp() {
-    await closeBrowser();
+    await closeBrowser(true);
   },
   async installApp() {
   },
   async uninstallApp() {
+    await closeBrowser(false);
   },
   async openURL(url) {
     const page = getPage();
@@ -14616,6 +15406,14 @@ var device = {
       definition: import_motion_change.MOTION_CHANGE_DEFINITION,
       installGlobal: true
     });
+    if (options.workletFrameTracePath) {
+      await page.evaluate(async (limit) => {
+        const enable = window.SootSim?.bridges?.test?.setShellReanimatedTraceEnabled;
+        if (typeof enable !== "function")
+          throw new Error("worklet trace bridge is absent");
+        await enable(true, true, limit);
+      }, WORKLET_FRAME_TRACE_LIMIT);
+    }
     const capturePromise = page.evaluate(
       async (input) => {
         const captureWindow = window;
@@ -14707,68 +15505,83 @@ var device = {
         if (input.hold && (!interact || typeof interact.touchDown !== "function")) {
           throw new Error("peach interact bridge is not installed");
         }
-        const controller = await lockstep.begin(60);
-        const moves = input.hold?.moves ?? [];
-        const holdState = {
-          nextMove: 0,
-          pressFrameIndex: null,
-          releaseReceipt: null,
-          released: false,
-          x: input.hold?.x ?? 0,
-          y: input.hold?.y ?? 0
-        };
-        const holdEventFrameIndex = (afterMs) => (holdState.pressFrameIndex ?? 0) + controller.framesForOffset(afterMs);
-        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,
-              999,
-              controller.initialFrame.virtualTimestampMs + move.afterMs
+        const pairedPeerStats = async (reset = false) => {
+          const stats = await captureWindow.SootSim?.bridges?.test?.getPeerStats?.(reset);
+          if (!stats || !Number.isSafeInteger(stats.replayedFrameCallbacks))
+            throw new Error(
+              "paired worklets clock needs native frame delivery diagnostics"
             );
-          }
-          if (receipt.frameIndex < holdEventFrameIndex(input.hold.durationMs)) return;
-          holdState.released = true;
-          holdState.releaseReceipt = receipt;
-          await interact.touchUp(
-            holdState.x,
-            holdState.y,
-            999,
-            controller.initialFrame.virtualTimestampMs + input.hold.durationMs
-          );
+          return stats;
         };
+        if (input.workletFrameTimestampsSeconds) await pairedPeerStats(true);
+        const controller = await lockstep.begin(60, {
+          workletFrameTimestampsSeconds: input.workletFrameTimestampsSeconds
+        });
+        let heldInput = null;
+        const releaseReceipt = () => controller.inputReceipts.find((receipt) => receipt.phase === "up");
         const keptFrames = /* @__PURE__ */ new Map();
+        const keepFrame = (receipt, bitmap) => {
+          keptFrames.get(receipt.frameIndex)?.bitmap.close();
+          keptFrames.set(receipt.frameIndex, { bitmap, receipt });
+        };
         try {
+          if (input.anchorAtTouch && !input.hold) {
+            throw new Error("peach touch anchoring needs a hold");
+          }
           const baselineBitmap = await captureBitmap();
           const baseline = regionPixels(baselineBitmap);
-          baselineBitmap.close();
+          if (input.anchorAtTouch === "down")
+            keepFrame(controller.initialFrame, baselineBitmap);
+          else baselineBitmap.close();
+          if (input.workletFrameTimestampsSeconds && (await pairedPeerStats()).replayedFrameCallbacks > 0)
+            throw new Error("paired worklets callback preceded the Peach trigger");
           state.ready = true;
           if (input.hold && interact) {
-            const hit = await interact.touchDown(
-              input.hold.x,
-              input.hold.y,
-              999,
-              controller.initialFrame.virtualTimestampMs
-            );
-            if (!hit) {
-              throw new Error(
-                `peach motion hold missed at ${input.hold.x},${input.hold.y}`
-              );
-            }
+            const hold = input.hold;
+            const moves = hold.moves ?? [];
+            const release = hold.release ?? moves.at(-1) ?? hold;
+            const events = [
+              {
+                phase: "down",
+                x: hold.x,
+                y: hold.y,
+                pointerId: 999,
+                afterMs: 0,
+                async deliver(timestamp2) {
+                  const hit = await interact.touchDown(hold.x, hold.y, 999, timestamp2);
+                  if (!hit)
+                    throw new Error(`peach motion hold missed at ${hold.x},${hold.y}`);
+                }
+              },
+              ...moves.map(
+                (move) => ({
+                  phase: "move",
+                  x: move.x,
+                  y: move.y,
+                  pointerId: 999,
+                  afterMs: move.afterMs,
+                  eventAfterMs: move.eventAfterMs,
+                  async deliver(timestamp2) {
+                    await interact.touchMove(move.x, move.y, 999, timestamp2);
+                  }
+                })
+              ),
+              {
+                phase: "up",
+                x: release.x,
+                y: release.y,
+                pointerId: 999,
+                afterMs: hold.durationMs,
+                eventAfterMs: hold.eventDurationMs,
+                async deliver(timestamp2) {
+                  await interact.touchUp(release.x, release.y, 999, timestamp2);
+                }
+              }
+            ];
+            heldInput = controller.scheduleInput(events);
+            heldInput.catch(() => {
+            });
+            await controller.flushFrame();
           } else {
             while (!state.triggerStarted) {
               if (state.cancelled) throw new Error("peach motion capture was cancelled");
@@ -14793,7 +15606,7 @@ var device = {
             if (measurement.passedMinimum) {
               visibleStart = receipt;
               detectedMeasurement = measurement;
-              keptFrames.set(visibleStart.frameIndex, candidateBitmap);
+              keepFrame(visibleStart, candidateBitmap);
             } else {
               candidateBitmap.close();
             }
@@ -14802,10 +15615,9 @@ var device = {
           for (let frame = 0; !visibleStart && 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();
-            if (input.anchorAtRelease && holdState.releaseReceipt === receipt) {
-              keptFrames.set(receipt.frameIndex, await createImageBitmap(candidateBitmap));
+            if (input.anchorAtTouch === "down" || input.anchorAtTouch === "up" && releaseReceipt()?.frameIndex === receipt.frameIndex) {
+              keepFrame(receipt, await createImageBitmap(candidateBitmap));
             }
             const bounds = boundsFor(candidateBitmap);
             const measurement = measureChange({
@@ -14821,8 +15633,7 @@ var device = {
               previousBitmap = null;
               visibleStart = receipt;
               detectedMeasurement = measurement;
-              keptFrames.get(receipt.frameIndex)?.close();
-              keptFrames.set(receipt.frameIndex, candidateBitmap);
+              keepFrame(receipt, candidateBitmap);
               break;
             }
             previousBitmap?.close();
@@ -14836,23 +15647,19 @@ var device = {
           }
           let driveStart = visibleStart;
           let currentReceipt = visibleStart;
-          if (input.anchorAtRelease) {
-            if (!input.hold) {
-              throw new Error("peach release anchoring needs a hold");
-            }
-            while (!holdState.released) {
+          if (input.anchorAtTouch === "down") driveStart = controller.initialFrame;
+          if (input.anchorAtTouch === "up") {
+            while (!releaseReceipt()) {
               if (state.cancelled) throw new Error("peach motion capture was cancelled");
               const receipt = await controller.stepFrame();
-              await advanceHold(receipt);
               currentReceipt = receipt;
-              if (holdState.released) {
-                keptFrames.set(receipt.frameIndex, await captureBitmap());
-              }
+              if (releaseReceipt()) keepFrame(receipt, await captureBitmap());
             }
-            if (!holdState.releaseReceipt) {
+            const released = releaseReceipt();
+            if (!released) {
               throw new Error("peach release anchoring found no release frame");
             }
-            driveStart = holdState.releaseReceipt;
+            driveStart = { ...released, tenantFrame: null };
           }
           const resolvedAnchors = /* @__PURE__ */ new Map();
           const anchorRecords = [];
@@ -14877,7 +15684,6 @@ var device = {
             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();
@@ -14889,7 +15695,6 @@ var device = {
             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);
@@ -14926,8 +15731,7 @@ var device = {
                 `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);
+            keepFrame(anchorReceipt, anchorBitmap);
             resolvedAnchors.set(anchor.id, anchorReceipt);
             anchorRecords.push({
               changedPixelPercent: onsetMeasurement.changePercent,
@@ -14946,21 +15750,17 @@ var device = {
             const kept = keptFrames.get(stageFrameIndex);
             if (kept && stageFrameIndex <= currentReceipt.frameIndex) {
               snapshots.push({
-                actualMs: 0,
+                actualMs: kept.receipt.virtualTimestampMs - anchorReceipt.virtualTimestampMs,
                 anchorId,
-                bitmap: await createImageBitmap(kept),
-                frameIndex: anchorReceipt.frameIndex,
+                bitmap: await createImageBitmap(kept.bitmap),
+                frameIndex: kept.receipt.frameIndex,
                 label: stage.label,
                 offsetMs: stage.offsetMs,
-                virtualTimestampMs: anchorReceipt.virtualTimestampMs
+                virtualTimestampMs: kept.receipt.virtualTimestampMs
               });
               continue;
             }
-            for (let eventFrameIndex = nextHoldEventFrameIndex(); eventFrameIndex !== null && stageFrameIndex > eventFrameIndex; eventFrameIndex = nextHoldEventFrameIndex()) {
-              await advanceHold(await controller.stepFrame());
-            }
             const receipt = await controller.stepToOffset(anchorReceipt, stage.offsetMs);
-            await advanceHold(receipt);
             currentReceipt = receipt;
             snapshots.push({
               actualMs: receipt.virtualTimestampMs - anchorReceipt.virtualTimestampMs,
@@ -14972,12 +15772,13 @@ var device = {
               virtualTimestampMs: receipt.virtualTimestampMs
             });
           }
+          if (input.workletFrameTimestampsSeconds) controller.endWorkletFrameReceipt();
           let releasedOffsetMs = 0;
-          while (nextHoldEventFrameIndex() !== null) {
+          while (input.hold && !releaseReceipt()) {
             const receipt = await controller.stepFrame();
-            await advanceHold(receipt);
             releasedOffsetMs = receipt.virtualTimestampMs - driveStart.virtualTimestampMs;
           }
+          await heldInput;
           if (input.settleMs > 0) {
             const maximumPrimaryMs = snapshots.reduce(
               (maximum, snapshot2) => Math.max(
@@ -14993,6 +15794,17 @@ var device = {
             await controller.stepFrame();
             await new Promise((resolve3) => setTimeout(resolve3, 0));
           }
+          if (input.workletFrameTimestampsSeconds) {
+            const stats = await pairedPeerStats();
+            const first = stats.nativeFrameFirstTimestampMs;
+            const firstFrameIndex = first === null ? null : Math.round(
+              (first - controller.initialFrame.virtualTimestampMs) / (1e3 / 60)
+            );
+            if (firstFrameIndex !== 1)
+              throw new Error(
+                `paired worklets first delivery did not match the next UI frame: ${firstFrameIndex}`
+              );
+          }
           return {
             inputReceipts: controller.inputReceipts,
             anchors: anchorRecords,
@@ -15013,15 +15825,16 @@ var device = {
             }
           };
         } finally {
-          for (const bitmap of keptFrames.values()) bitmap.close();
+          for (const kept of keptFrames.values()) kept.bitmap.close();
           controller.end();
           delete registry[input.token];
         }
       },
       {
+        workletFrameTimestampsSeconds: options.workletFrameTimestampsSeconds,
         detectionTimeoutMs: options.detectionTimeoutMs ?? 3e3,
         frame: options.frame ?? null,
-        anchorAtRelease: options.anchorAtRelease ?? false,
+        anchorAtTouch: options.anchorAtTouch ?? null,
         hold: options.hold ?? null,
         motionChangeDefinition: import_motion_change.MOTION_CHANGE_DEFINITION,
         platform: device.getPlatform(),
@@ -15031,17 +15844,24 @@ var device = {
         token
       }
     );
-    await page.waitForFunction(
-      (captureToken) => {
-        const registry = window.__sootsimVisibleChangeCaptures;
-        return registry?.[captureToken]?.ready === true;
-      },
-      token,
-      { timeout: 5e3 }
-    );
-    const triggerStartMs = Date.now();
+    let captureFailure;
+    let triggerStartMs = 0;
     let triggerCompletedMs = 0;
     try {
+      await Promise.race([
+        page.waitForFunction(
+          (captureToken) => {
+            const registry = window.__sootsimVisibleChangeCaptures;
+            return registry?.[captureToken]?.ready === true;
+          },
+          token,
+          { timeout: 5e3 }
+        ),
+        capturePromise.then(() => {
+          throw new Error("peach motion capture completed before its trigger");
+        })
+      ]);
+      triggerStartMs = Date.now();
       const triggerPromise = (async () => {
         if (!options.hold) {
           if (typeof options.trigger !== "function") {
@@ -15077,6 +15897,7 @@ var device = {
         }
       };
     } catch (error) {
+      captureFailure = { error };
       await page.evaluate((captureToken) => {
         const registry = window.__sootsimVisibleChangeCaptures;
         const capture = registry?.[captureToken];
@@ -15086,6 +15907,55 @@ var device = {
       await capturePromise.catch(() => {
       });
       throw error;
+    } finally {
+      if (options.workletFrameTracePath) {
+        try {
+          const events = await page.evaluate(async () => {
+            const test = window.SootSim?.bridges?.test;
+            const read = test?.getShellReanimatedTrace;
+            const enable = test?.setShellReanimatedTraceEnabled;
+            if (typeof read !== "function" || typeof enable !== "function")
+              throw new Error("worklet trace bridge is absent");
+            try {
+              return await read();
+            } finally {
+              await enable(false, false);
+            }
+          });
+          fs2.writeFileSync(
+            options.workletFrameTracePath,
+            JSON.stringify(
+              {
+                source: "peach-native-frame-queue",
+                limit: WORKLET_FRAME_TRACE_LIMIT,
+                events
+              },
+              null,
+              2
+            )
+          );
+        } catch (traceError) {
+          if (!captureFailure) throw traceError;
+          const primary = captureFailure.error;
+          if (primary && (typeof primary === "object" || typeof primary === "function") && Object.isExtensible(primary)) {
+            try {
+              Object.defineProperty(primary, "workletFrameTraceError", {
+                value: traceError,
+                configurable: true
+              });
+            } catch (attachmentError) {
+              console.error(
+                "[peach motion capture] could not attach trace failure:",
+                attachmentError
+              );
+            }
+          }
+          console.error(
+            "[peach motion capture] secondary worklet trace failure:",
+            traceError
+          );
+        }
+      }
     }
   },
   // FAST multi-stage capture for sub-second animation diffs. each stage
@@ -15483,7 +16353,7 @@ async function cleanup() {
   _browserLaunchAbort?.abort(new Error("Peach driver cleaned up"));
   await _browserLaunch?.catch(() => {
   });
-  await closeBrowser();
+  await closeBrowser(false);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {