peachsim 0.1.1640 → 0.1.1641

package/dist-lib/detox/index.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1640 | (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;
@@ -1524,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, {
@@ -1655,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)
@@ -1735,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 = {
@@ -1761,6 +1786,7 @@ var require_native_frame_receipt = __commonJS({
       requireNativeProducerFrame,
       requireNativeRawFrame,
       decodeNativeFramebuffer,
+      nativeFramebufferPixels,
       writeNativeFramebufferPng
     };
     async function buildNativeFrameConsumer({ root, cacheRoot, waitForAdmission = false }) {
@@ -1896,7 +1922,10 @@ var require_native_frame_receipt = __commonJS({
         ticks.push({
           targetTimestampSeconds: row.targetTimestampSeconds,
           timestampSeconds: row.timestampSeconds,
-          durationSeconds: row.durationSeconds
+          durationSeconds: row.durationSeconds,
+          clockBridge: row.clockBridge,
+          callbackThread: row.callbackThread,
+          callbackWasMainThread: row.callbackWasMainThread
         });
       }
       if (ticks.length < 2)
@@ -1910,7 +1939,7 @@ var require_native_frame_receipt = __commonJS({
       };
     }
     module2.exports.nativeUIFrameClockReceipt = nativeUIFrameClockReceipt;
-    function pairedNativeWorkletFrameClock(root, lifecycle) {
+    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");
@@ -1940,6 +1969,42 @@ var require_native_frame_receipt = __commonJS({
           )
         )
       );
+      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");
@@ -1965,6 +2030,323 @@ var require_native_frame_receipt = __commonJS({
       };
     }
     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");
@@ -1991,27 +2373,6 @@ var require_native_frame_receipt = __commonJS({
       });
       if (times.some((value, index) => index > 0 && value <= times[index - 1]))
         throw new Error("nonmonotonic native source arrivals");
-      const reads = rows.map((row) => ({
-        callbackIndex: row.callbackIndex,
-        seedBeforeRead: row.source?.seedBeforeRead,
-        seedAfterRead: row.source?.seedAfterRead,
-        arrival: BigInt(row.consumerArrival.machTicks)
-      }));
-      for (const [index, read] of reads.entries()) {
-        if (!Number.isSafeInteger(read.seedBeforeRead) || !Number.isSafeInteger(read.seedAfterRead))
-          throw new Error(`native callback ${read.callbackIndex} has no surface seed`);
-        const previous = reads[index - 1];
-        if (!previous) continue;
-        const lost = read.seedBeforeRead - previous.seedAfterRead - 1;
-        if (lost > 1) {
-          const gapMs = Number(
-            (read.arrival - previous.arrival) * BigInt(firstClock.timebaseNumer) / BigInt(firstClock.timebaseDenom)
-          ) / 1e6;
-          throw new Error(
-            `native recording skipped ${lost} surface updates between callbacks ${previous.callbackIndex} and ${read.callbackIndex} (surface seed ${previous.seedAfterRead} to ${read.seedBeforeRead}, ${gapMs.toFixed(1)}ms between arrivals): no captured frame shows them`
-          );
-        }
-      }
       function selectTime(start, end) {
         if (end - start === 1) return String(times[start]);
         const middle = Math.floor((start + end) / 2);
@@ -2415,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(
@@ -2432,10 +2797,10 @@ var require_attempt_events = __commonJS({
         root,
         native.mediaFrames,
         native.mediaFramesSha256,
-        "native cadence presentation census"
+        "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
@@ -2454,12 +2819,22 @@ var require_attempt_events = __commonJS({
           return row.callbackIndex;
         })
       );
-      const origin = frames[0].consumerArrival;
+      const reads = boundText(
+        root,
+        native.reads,
+        native.readsSha256,
+        "native cadence observations"
+      ).split("\n").filter(Boolean).map(JSON.parse);
       let expectedCallback = 0;
-      for (const [index, frame] of frames.entries()) {
+      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 !== expectedCallback++ || 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)
@@ -2723,6 +3098,26 @@ var require_attempt_events = __commonJS({
             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(
@@ -13139,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;
@@ -13415,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"
     );
   }
 }
@@ -14629,6 +15029,7 @@ var device = {
   async installApp() {
   },
   async uninstallApp() {
+    await closeBrowser(false);
   },
   async openURL(url) {
     const page = getPage();
@@ -15005,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;
@@ -15108,49 +15517,8 @@ var device = {
         const controller = await lockstep.begin(60, {
           workletFrameTimestampsSeconds: input.workletFrameTimestampsSeconds
         });
-        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
-            );
-          }
-          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
-          );
-        };
+        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();
@@ -15169,17 +15537,51 @@ var device = {
             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");
@@ -15213,9 +15615,8 @@ 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.anchorAtTouch === "down" || input.anchorAtTouch === "up" && holdState.releaseReceipt === receipt) {
+            if (input.anchorAtTouch === "down" || input.anchorAtTouch === "up" && releaseReceipt()?.frameIndex === receipt.frameIndex) {
               keepFrame(receipt, await createImageBitmap(candidateBitmap));
             }
             const bounds = boundsFor(candidateBitmap);
@@ -15248,17 +15649,17 @@ var device = {
           let currentReceipt = visibleStart;
           if (input.anchorAtTouch === "down") driveStart = controller.initialFrame;
           if (input.anchorAtTouch === "up") {
-            while (!holdState.released) {
+            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) keepFrame(receipt, 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 = [];
@@ -15283,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();
@@ -15295,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);
@@ -15361,11 +15760,7 @@ var device = {
               });
               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,
@@ -15379,11 +15774,11 @@ var device = {
           }
           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(
@@ -15449,22 +15844,24 @@ var device = {
         token
       }
     );
-    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");
-      })
-    ]);
-    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") {
@@ -15500,6 +15897,7 @@ var device = {
         }
       };
     } catch (error) {
+      captureFailure = { error };
       await page.evaluate((captureToken) => {
         const registry = window.__sootsimVisibleChangeCaptures;
         const capture = registry?.[captureToken];
@@ -15509,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