peachsim 0.1.1635 → 0.1.1640

package/dist-lib/detox/index.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1635 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1640 | (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,
@@ -1757,6 +1872,99 @@ 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
+        });
+      }
+      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) {
+      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"
+          )
+        )
+      );
+      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;
     async function encodeNativeFramebufferMovie(rawDir, videoPath) {
       const fs3 = require("node:fs");
       const path5 = require("node:path");
@@ -1783,6 +1991,27 @@ 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);
@@ -1979,6 +2208,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));
@@ -2186,8 +2422,18 @@ 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 presentation 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");
       const {
@@ -2195,10 +2441,25 @@ var require_attempt_events = __commonJS({
         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 origin = frames[0].consumerArrival;
+      let expectedCallback = 0;
       for (const [index, frame] of frames.entries()) {
+        while (superseded.delete(expectedCallback)) expectedCallback++;
         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 (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)
           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 +2472,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,9 +2708,20 @@ 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);
             const rows = fs3.readFileSync(proofBoundPath(root, native.receipt), "utf8").trim().split("\n").map(JSON.parse);
             for (const row of rows) {
@@ -6348,6 +6623,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 +7642,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 +8126,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 +10919,10 @@ function setPauseAwareTimeout(fn, budgetMs, hostPid) {
   }
   return () => {
     timers.delete(timer);
+    if (timers.size === 0 && poll) {
+      clearInterval(poll);
+      poll = void 0;
+    }
   };
 }
 
@@ -10674,7 +10961,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 +11104,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 +11117,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 +11350,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 +12366,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 +12466,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 +12587,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 +12604,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 +12630,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 +12690,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);
@@ -12773,6 +13146,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 +13342,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 +13389,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,
@@ -13092,7 +13470,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 +13479,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 +13499,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 +13509,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 +13745,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 +14134,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 +14515,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,7 +14624,7 @@ var device = {
     await waitForSootsimWorkletsIdle(page, 3e3);
   },
   async terminateApp() {
-    await closeBrowser();
+    await closeBrowser(true);
   },
   async installApp() {
   },
@@ -14707,7 +15096,18 @@ 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 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"
+            );
+          return stats;
+        };
+        if (input.workletFrameTimestampsSeconds) await pairedPeerStats(true);
+        const controller = await lockstep.begin(60, {
+          workletFrameTimestampsSeconds: input.workletFrameTimestampsSeconds
+        });
         const moves = input.hold?.moves ?? [];
         const holdState = {
           nextMove: 0,
@@ -14752,10 +15152,21 @@ var device = {
           );
         };
         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(
@@ -14793,7 +15204,7 @@ var device = {
             if (measurement.passedMinimum) {
               visibleStart = receipt;
               detectedMeasurement = measurement;
-              keptFrames.set(visibleStart.frameIndex, candidateBitmap);
+              keepFrame(visibleStart, candidateBitmap);
             } else {
               candidateBitmap.close();
             }
@@ -14804,8 +15215,8 @@ var device = {
             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" && holdState.releaseReceipt === receipt) {
+              keepFrame(receipt, await createImageBitmap(candidateBitmap));
             }
             const bounds = boundsFor(candidateBitmap);
             const measurement = measureChange({
@@ -14821,8 +15232,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,18 +15246,14 @@ var device = {
           }
           let driveStart = visibleStart;
           let currentReceipt = visibleStart;
-          if (input.anchorAtRelease) {
-            if (!input.hold) {
-              throw new Error("peach release anchoring needs a hold");
-            }
+          if (input.anchorAtTouch === "down") driveStart = controller.initialFrame;
+          if (input.anchorAtTouch === "up") {
             while (!holdState.released) {
               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 (holdState.released) keepFrame(receipt, await captureBitmap());
             }
             if (!holdState.releaseReceipt) {
               throw new Error("peach release anchoring found no release frame");
@@ -14926,8 +15332,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,13 +15351,13 @@ 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;
             }
@@ -14972,6 +15377,7 @@ var device = {
               virtualTimestampMs: receipt.virtualTimestampMs
             });
           }
+          if (input.workletFrameTimestampsSeconds) controller.endWorkletFrameReceipt();
           let releasedOffsetMs = 0;
           while (nextHoldEventFrameIndex() !== null) {
             const receipt = await controller.stepFrame();
@@ -14993,6 +15399,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 +15430,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,14 +15449,19 @@ var device = {
         token
       }
     );
-    await page.waitForFunction(
-      (captureToken) => {
-        const registry = window.__sootsimVisibleChangeCaptures;
-        return registry?.[captureToken]?.ready === true;
-      },
-      token,
-      { timeout: 5e3 }
-    );
+    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 triggerCompletedMs = 0;
     try {
@@ -15483,7 +15906,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 = {