peachsim 0.1.1644 → 0.1.1653

package/detox/index.ts

@@ -13,24 +13,19 @@ import {
   reserveChromiumAdmission,
   type ChromiumLaunchAdmission,
 } from '../../../scripts/lib/reap-browser'
-import { automateWebAuthenticationSessions } from '../../peach-engine/src/web-authentication-automation-host'
+import {
+  MOTION_CHANGE_DEFINITION,
+  type DiscreteFrameCadence,
+  type MotionChangeDefinition,
+} from '../../peach-conformance/src/cases/checkpoint-evidence.cjs'
+import { getCliRuntime } from '../src/cli-runtime.ts'
 import type {
   LockstepInputReceipt,
   LockstepScheduledInput,
   SootSimLockstepFrameReceipt,
 } from '@peach/globals'
 export { reserveChromiumAdmission } from '../../../scripts/lib/reap-browser'
-import {
-  readBrowserCompositeCaptureRequest,
-  resolveBrowserCompositeCdpClip,
-} from '../../peach-engine/src/capture/browser-composite'
-import { WEBVIEW_HOST_BOOTSTRAP_SOURCE } from '../../peach-engine/src/components/native-ui/webview-frame-bridge'
-import { isAppBootTargetUrl } from '../../peach-engine/src/render-worker/app-load'
-import {
-  automateWebViewFrames,
-  webViewAutomationHelpers,
-  webViewAutomationNames,
-} from '../../peach-engine/src/webview-automation-host'
+
 import { waitForSootsimIdle as waitForRuntimeIdle } from '../cli/commands/inspect/settling'
 import { createBridge } from '../cli/ws-bridge'
 import { resolveSootsimBridgePortForHttpPort } from '../src/bridge-constants'
@@ -45,6 +40,7 @@ import {
   isTextInputNodeFocused,
   isNodeVisible,
 } from './expectations'
+import { frameTimingRoundingBound } from './frame-offset.mjs'
 import {
   dispatchTwoFingerGesture,
   DETOX_PLATFORM,
@@ -57,13 +53,10 @@ import {
 } from './gestures'
 import { by, type Matcher } from './matchers'
 import {
-  MOTION_CHANGE_DEFINITION,
   measureMotionChange,
   classifyDiscreteFrame,
-  type DiscreteFrameCadence,
   type DiscreteFrameObservation,
   type DiscreteFrameTrace,
-  type MotionChangeDefinition,
   type MotionChangeMeasurement,
 } from './motion-change.cjs'
 import { describeSootsimBridgeFailure, navigateSootsimPage } from './navigation-lifecycle'
@@ -277,7 +270,8 @@ export async function waitForSootsimShellReady(
   // shell first paint for home boots, compositor app-surface first paint for
   // app boots.
   // exported for the focused regression test.
-  const expectsInitialAppPaint = isAppBootTargetUrl(page.url())
+  const expectsInitialAppPaint =
+    getCliRuntime().render_worker_app_load.isAppBootTargetUrl(page.url())
   try {
     await page.evaluate(
       async ({ timeoutMs, expectsInitialAppPaint }) => {
@@ -2027,23 +2021,28 @@ export const device = {
         reapOwnedBrowser()
         throw error
       }
-      await automateWebViewFrames(
+      await getCliRuntime().webview_automation_host.automateWebViewFrames(
         _context,
-        webViewAutomationNames(
+        getCliRuntime().webview_automation_host.webViewAutomationNames(
           `peachwv${randomBytes(12).toString('hex')}`,
-          WEBVIEW_HOST_BOOTSTRAP_SOURCE,
+          getCliRuntime().components_native_ui_webview_frame_bridge
+            .WEBVIEW_HOST_BOOTSTRAP_SOURCE,
         ),
-        webViewAutomationHelpers,
+        getCliRuntime().webview_automation_host.webViewAutomationHelpers,
         (page) => page.workers(),
       )
       await _context.exposeBinding('__sootsimHostCapture', async (source, value) => {
-        const request = readBrowserCompositeCaptureRequest(value)
+        const request =
+          getCliRuntime().capture_browser_composite.readBrowserCompositeCaptureRequest(
+            value,
+          )
         const session = await source.page.context().newCDPSession(source.page)
         try {
-          const { clip, originX, originY } = resolveBrowserCompositeCdpClip(
-            request,
-            await session.send('Page.getLayoutMetrics'),
-          )
+          const { clip, originX, originY } =
+            getCliRuntime().capture_browser_composite.resolveBrowserCompositeCdpClip(
+              request,
+              await session.send('Page.getLayoutMetrics'),
+            )
           const result = await session.send('Page.captureScreenshot', {
             format: 'png',
             fromSurface: true,
@@ -2064,7 +2063,7 @@ export const device = {
         reapOwnedBrowser()
         throw error
       }
-      await automateWebAuthenticationSessions(
+      await getCliRuntime().web_authentication_automation_host.automateWebAuthenticationSessions(
         _context!,
         '__peachWebAuthenticationHost',
         _page,
@@ -2310,6 +2309,7 @@ export const device = {
           }
           lockstepCapture: {
             begin: (fps: number) => Promise<{
+              framesForOffset: (offsetMs: number) => number
               stepFrame: () => Promise<{ frameIndex: number; virtualTimestampMs: number }>
               end: () => void
             }>
@@ -2366,6 +2366,7 @@ export const device = {
         let baseMs: number | null = null
         let currentMs = 0
         let anchorMs: number | null = null
+        let anchorFrameIndex = 0
         const stageFrames: DiscreteStageFrame[] = []
         const observeTick = async () => {
           const receipt = await controller.stepFrame()
@@ -2406,14 +2407,16 @@ export const device = {
             anchorMs === null &&
             classification.phase === cadence.entryFrame &&
             rows[0].phase !== cadence.entryFrame
-          )
+          ) {
             anchorMs = currentMs
+            anchorFrameIndex = rows.length - 1
+          }
           if (anchorMs !== null) {
             const next = stages[stageFrames.length]
             if (
               next &&
-              currentMs + 0.00001 >=
-                anchorMs + (Math.ceil((next.offsetMs * 60) / 1000) * 1000) / 60
+              rows.length - 1 >=
+                anchorFrameIndex + controller.framesForOffset(next.offsetMs)
             ) {
               requestedPngs++
               stageFrames.push({
@@ -2433,20 +2436,13 @@ export const device = {
             step: async (durationMs) => {
               if (!Number.isFinite(durationMs) || durationMs < 0)
                 throw new Error('peach discrete wait needs a nonnegative duration')
-              const end = currentMs + durationMs
-              // a wait reaching the playing horizon covers it exactly: the
-              // receiver compares coverage with anchor + 1900 without slack
-              const horizon =
-                cadence.mode === 'playing' && anchorMs !== null ? anchorMs + 1900 : null
-              while (
-                currentMs + 0.00001 < end ||
-                (horizon !== null && end + 0.00001 >= horizon && currentMs < horizon)
-              ) {
-                if (
-                  cadence.mode === 'playing' &&
-                  anchorMs !== null &&
-                  currentMs >= anchorMs + 1900
-                ) {
+              const endFrame = rows.length - 1 + controller.framesForOffset(durationMs)
+              const horizonFrame =
+                cadence.mode === 'playing' && anchorMs !== null
+                  ? anchorFrameIndex + controller.framesForOffset(1900)
+                  : null
+              while (rows.length - 1 < endFrame) {
+                if (horizonFrame !== null && rows.length - 1 >= horizonFrame) {
                   await new Promise((resolve) => setTimeout(resolve, 1000 / 60))
                   break
                 }
@@ -2601,6 +2597,8 @@ export const device = {
         throw new Error('discrete capture missed requested stages')
       const discreteTrace = await this.endProofFrameObservation()
       ended = true
+      const anchorFrame = discreteTrace.observations.find((row) => row.atMs === anchorMs)
+      if (!anchorFrame) throw new Error('discrete capture has no observed anchor frame')
       discreteTrace.triggerStartedAtMs = triggerStartMs
       discreteTrace.triggerCompletedAtMs = triggerCompletedMs
       discreteTrace.completedAtMs = Date.now()
@@ -2610,7 +2608,7 @@ export const device = {
         triggerCompletedMs,
         discreteTrace,
         driveStart: {
-          frameIndex: Math.round((anchorMs * 60) / 1000),
+          frameIndex: anchorFrame.frameIndex,
           virtualTimestampMs: anchorMs,
         },
         anchors: [],
@@ -2668,6 +2666,9 @@ export const device = {
       // delivers its release ('up') rather than from the first visible
       // change, the delivered touch anchor the native lane uses.
       anchorAtTouch?: 'down' | 'up'
+      // a witnessed drag replays native delivered times and samples the
+      // declared offsets directly, as the native lane does.
+      witnessedDrag?: boolean
       rootFrame?: { height: number; width: number; x: number; y: number } | null
       settleMs?: number
       trigger?: () => unknown
@@ -2704,7 +2705,7 @@ export const device = {
       totalPixels: number
       frameIndex: number
       virtualTimestampMs: number
-    }
+    } | null
   }> {
     const page = getPage()
     const token = `motion-${process.pid}-${Date.now()}-${Math.random()}`
@@ -2725,6 +2726,7 @@ export const device = {
       }, WORKLET_FRAME_TRACE_LIMIT)
     }
     const capturePromise: Promise<{
+      workletFirstDelivery: { first: number | null; initial: number } | null
       inputReceipts: LockstepInputReceipt[]
       anchors: Array<{
         changedPixelPercent: number
@@ -2750,7 +2752,7 @@ export const device = {
         minimumChangePercent: number
         totalPixels: number
         virtualTimestampMs: number
-      }
+      } | null
     }> = page.evaluate(
       async (input) => {
         type CaptureWindow = Window & {
@@ -2975,7 +2977,13 @@ export const device = {
             heldInput.catch(() => {})
             await controller.flushFrame()
           } else {
-            while (!state.triggerStarted) {
+            // the paired receipt starts after native touch-up. target lookup
+            // and synthetic press delivery must finish before consuming it.
+            while (
+              !(input.workletFrameTimestampsSeconds
+                ? state.triggerCompleted
+                : state.triggerStarted)
+            ) {
               if (state.cancelled) throw new Error('peach motion capture was cancelled')
               await new Promise((resolve) => setTimeout(resolve, 0))
             }
@@ -2984,8 +2992,12 @@ export const device = {
           let visibleStart: SootSimLockstepFrameReceipt | null = null
           let detectedMeasurement: MotionChangeMeasurement | null = null
           let previousBitmap: ImageBitmap | null = null
+          const detectionFrameLimit = controller.framesForOffset(input.detectionTimeoutMs)
+          // a touch anchor takes stage zero from the delivered touch on both
+          // legs, so no visible change gates its drive; a feedback below the
+          // change minimum still captures, as it does natively.
           // android can publish mount layout at p=0 before a clock step.
-          if (input.platform === 'android') {
+          if (!input.anchorAtTouch && input.platform === 'android') {
             // time zero needs the same producer publication fence as stepped
             // frames; intermediate tree paints are not a transition onset.
             const receipt = await controller.flushFrame()
@@ -3007,19 +3019,14 @@ export const device = {
               candidateBitmap.close()
             }
           }
-          const detectionFrameLimit = Math.ceil((input.detectionTimeoutMs * 60) / 1000)
-          for (let frame = 0; !visibleStart && frame < detectionFrameLimit; frame++) {
+          for (
+            let frame = 0;
+            !input.anchorAtTouch && !visibleStart && frame < detectionFrameLimit;
+            frame++
+          ) {
             if (state.cancelled) throw new Error('peach motion capture was cancelled')
             const receipt = await controller.stepFrame()
             const candidateBitmap = await captureBitmap()
-            // a touch anchor's stages may precede the first visible change
-            if (
-              input.anchorAtTouch === 'down' ||
-              (input.anchorAtTouch === 'up' &&
-                releaseReceipt()?.frameIndex === receipt.frameIndex)
-            ) {
-              keepFrame(receipt, await createImageBitmap(candidateBitmap))
-            }
             const bounds = boundsFor(candidateBitmap)
             const measurement = measureChange({
               baseline,
@@ -3040,22 +3047,36 @@ export const device = {
             previousBitmap?.close()
             previousBitmap = candidateBitmap
           }
-          if (!visibleStart || !detectedMeasurement) {
-            previousBitmap?.close()
-            throw new Error(
-              `peach motion had no visible change before ${input.detectionTimeoutMs}ms`,
-            )
-          }
+          previousBitmap?.close()
           // stages on every platform measure from the first frame that
           // differs from baseline: native extraction anchors at its
           // detection frame's pts, so the drive starts here too. the
           // preceding tick is still baseline on both legs. a touch anchor
           // instead starts the drive at the press or at the frame that
           // delivers the touch-up.
-          let driveStart = visibleStart
-          let currentReceipt = visibleStart
-          if (input.anchorAtTouch === 'down') driveStart = controller.initialFrame
-          if (input.anchorAtTouch === 'up') {
+          let driveStart: SootSimLockstepFrameReceipt
+          let currentReceipt: SootSimLockstepFrameReceipt
+          if (!input.anchorAtTouch) {
+            if (!visibleStart || !detectedMeasurement) {
+              throw new Error(
+                `peach motion had no visible change before ${input.detectionTimeoutMs}ms`,
+              )
+            }
+            driveStart = visibleStart
+            currentReceipt = visibleStart
+          } else if (input.anchorAtTouch === 'down') {
+            const press = controller.inputReceipts.find(
+              (receipt) => receipt.phase === 'down',
+            )
+            if (press?.frameIndex !== controller.initialFrame.frameIndex) {
+              throw new Error(
+                'peach press anchoring found no press delivered on the baseline frame',
+              )
+            }
+            driveStart = controller.initialFrame
+            currentReceipt = controller.initialFrame
+          } else {
+            currentReceipt = controller.initialFrame
             while (!releaseReceipt()) {
               if (state.cancelled) throw new Error('peach motion capture was cancelled')
               const receipt = await controller.stepFrame()
@@ -3099,15 +3120,17 @@ export const device = {
             // proof.js owns the default and fills it; this backstop only
             // serves direct shim callers.
             const onsetThresholdPercent = anchor.onsetThresholdPercent ?? 5
+            const searchStartFrame =
+              driveStart.frameIndex + controller.framesForOffset(anchor.notBeforeMs)
             const searchStartVts = driveStart.virtualTimestampMs + anchor.notBeforeMs
-            if (currentReceipt.virtualTimestampMs > searchStartVts) {
+            if (currentReceipt.frameIndex > searchStartFrame) {
               throw new Error(
                 `peach motion anchor ${anchor.id} searches from ${anchor.notBeforeMs}ms but the clock already sits past it: the ladder is unexecutable`,
               )
             }
             // step, never jump, to the search start so hold moves land.
             let searchReceipt = currentReceipt
-            while (searchReceipt.virtualTimestampMs < searchStartVts) {
+            while (searchReceipt.frameIndex < searchStartFrame) {
               if (state.cancelled) throw new Error('peach motion capture was cancelled')
               searchReceipt = await controller.stepFrame()
             }
@@ -3173,12 +3196,42 @@ export const device = {
             return { anchorId: anchor.id, receipt: anchorReceipt }
           }
 
+          // the hold's schedule in delivery order, in ms after the press.
+          const holdScheduleMs = input.hold
+            ? [
+                0,
+                ...(input.hold.moves ?? []).map((move) => move.afterMs),
+                input.hold.durationMs,
+              ].sort((a, b) => a - b)
+            : []
+          // transition stages take the native touch rule from the touches this
+          // lane delivered, stepping until the last one due has landed.
+          const stageOffsetMs = async (offsetMs: number, anchorId: string) => {
+            if (anchorId !== 'transition' || input.witnessedDrag) return offsetMs
+            const due = holdScheduleMs.filter((scheduledMs) => scheduledMs <= offsetMs)
+            while (controller.inputReceipts.length < due.length) {
+              if (state.cancelled) throw new Error('peach motion capture was cancelled')
+              currentReceipt = await controller.stepFrame()
+            }
+            const [press] = controller.inputReceipts
+            return controller.stageTouchOffsetMs(
+              due.map((scheduledMs, index) => ({
+                scheduledMs,
+                landedMs:
+                  controller.inputReceipts[index].virtualTimestampMs -
+                  press.virtualTimestampMs,
+              })),
+              offsetMs,
+            )
+          }
+
           const snapshots: Snapshot[] = []
           for (const stage of input.stages) {
             if (state.cancelled) throw new Error('peach motion capture was cancelled')
             const { anchorId, receipt: anchorReceipt } = await resolveAnchor(stage)
+            const touchOffsetMs = await stageOffsetMs(stage.offsetMs, anchorId)
             const stageFrameIndex =
-              anchorReceipt.frameIndex + controller.framesForOffset(stage.offsetMs)
+              anchorReceipt.frameIndex + controller.framesForOffset(touchOffsetMs)
             const kept = keptFrames.get(stageFrameIndex)
             if (kept && stageFrameIndex <= currentReceipt.frameIndex) {
               snapshots.push({
@@ -3193,7 +3246,7 @@ export const device = {
               })
               continue
             }
-            const receipt = await controller.stepToOffset(anchorReceipt, stage.offsetMs)
+            const receipt = await controller.stepToOffset(anchorReceipt, touchOffsetMs)
             currentReceipt = receipt
             snapshots.push({
               actualMs: receipt.virtualTimestampMs - anchorReceipt.virtualTimestampMs,
@@ -3233,21 +3286,16 @@ export const device = {
             await controller.stepFrame()
             await new Promise((resolve) => setTimeout(resolve, 0))
           }
-          if (input.workletFrameTimestampsSeconds) {
-            const stats = await pairedPeerStats()
-            const first = stats.nativeFrameFirstTimestampMs
-            const firstFrameIndex =
-              first === null
-                ? null
-                : Math.round(
-                    (first - controller.initialFrame.virtualTimestampMs) / (1000 / 60),
-                  )
-            if (firstFrameIndex !== 1)
-              throw new Error(
-                `paired worklets first delivery did not match the next UI frame: ${firstFrameIndex}`,
-              )
-          }
+          const stats = input.workletFrameTimestampsSeconds
+            ? await pairedPeerStats()
+            : null
           return {
+            workletFirstDelivery: stats
+              ? {
+                  first: stats.nativeFrameFirstTimestampMs,
+                  initial: controller.initialFrame.virtualTimestampMs,
+                }
+              : null,
             inputReceipts: controller.inputReceipts,
             anchors: anchorRecords,
             driveStart: {
@@ -3255,16 +3303,20 @@ export const device = {
               virtualTimestampMs: driveStart.virtualTimestampMs,
             },
             frames: snapshots.map(encode),
-            visibleChangeDetection: {
-              actualMs: (visibleStart.frameIndex * 1000) / 60,
-              changedPixelPercent: detectedMeasurement.changePercent,
-              changedPixels: detectedMeasurement.changePixels,
-              channelThreshold: input.motionChangeDefinition.channelThreshold,
-              minimumChangePercent: input.motionChangeDefinition.minimumChangePercent,
-              totalPixels: detectedMeasurement.totalPixels,
-              frameIndex: visibleStart.frameIndex,
-              virtualTimestampMs: visibleStart.virtualTimestampMs,
-            },
+            visibleChangeDetection:
+              visibleStart && detectedMeasurement
+                ? {
+                    actualMs: (visibleStart.frameIndex * 1000) / 60,
+                    changedPixelPercent: detectedMeasurement.changePercent,
+                    changedPixels: detectedMeasurement.changePixels,
+                    channelThreshold: input.motionChangeDefinition.channelThreshold,
+                    minimumChangePercent:
+                      input.motionChangeDefinition.minimumChangePercent,
+                    totalPixels: detectedMeasurement.totalPixels,
+                    frameIndex: visibleStart.frameIndex,
+                    virtualTimestampMs: visibleStart.virtualTimestampMs,
+                  }
+                : null,
           }
         } finally {
           for (const kept of keptFrames.values()) kept.bitmap.close()
@@ -3277,6 +3329,7 @@ export const device = {
         detectionTimeoutMs: options.detectionTimeoutMs ?? 3000,
         frame: options.frame ?? null,
         anchorAtTouch: options.anchorAtTouch ?? null,
+        witnessedDrag: options.witnessedDrag === true,
         hold: options.hold ?? null,
         motionChangeDefinition: MOTION_CHANGE_DEFINITION,
         platform: device.getPlatform(),
@@ -3327,6 +3380,19 @@ export const device = {
         }, token)
       })()
       const [capture] = await Promise.all([capturePromise, triggerPromise])
+      if (capture.workletFirstDelivery) {
+        const { first, initial } = capture.workletFirstDelivery
+        const interval = 1000 / 60
+        if (
+          first === null ||
+          !Number.isFinite(first) ||
+          Math.abs(first - initial - interval) >
+            frameTimingRoundingBound(first, initial, interval)
+        )
+          throw new Error(
+            `paired worklets first delivery did not match the next UI frame: ${first}`,
+          )
+      }
       return {
         inputReceipts: capture.inputReceipts,
         anchors: capture.anchors,
@@ -3334,11 +3400,13 @@ export const device = {
         frames: writeFastScreenshotFrames(namePrefix, capture.frames),
         triggerCompletedMs,
         triggerStartMs,
-        visibleChangeDetection: {
-          ...capture.visibleChangeDetection,
-          frame: options.frame ?? null,
-          rootFrame: options.rootFrame ?? null,
-        },
+        visibleChangeDetection: capture.visibleChangeDetection
+          ? {
+              ...capture.visibleChangeDetection,
+              frame: options.frame ?? null,
+              rootFrame: options.rootFrame ?? null,
+            }
+          : null,
       }
     } catch (error) {
       captureFailure = { error }

package/detox/jest-preset.cjs

@@ -22,9 +22,7 @@ module.exports = {
   // keep per-pixel arithmetic inside the module instead of the vm global proxy.
   sandboxInjectedGlobals: ['Math'],
   setupFilesAfterEnv: [path.join(PACKAGE_ROOT, 'detox', 'jest-setup-after-env.cjs')],
-  transform: {
-    '^.+\\.[jt]sx?$': ['@sucrase/jest-plugin', { jsxRuntime: 'automatic' }],
-  },
+  transform: require('./jest-transform.cjs'),
   moduleNameMapper: {
     '^detox$': DRIVER_ENTRY,
   },

package/detox/jest-transform.cjs

@@ -0,0 +1,4 @@
+// native and peach conformance share module syntax, including esm helpers.
+module.exports = {
+  '^.+\\.(?:[jt]sx?|mjs)$': ['@sucrase/jest-plugin', { jsxRuntime: 'automatic' }],
+}

package/detox/matchers.ts

@@ -7,6 +7,9 @@ export type Matcher = SootSimTargetMatcher
 
 function createMatcher(type: 'id' | 'text' | 'label', value: string | RegExp): Matcher {
   if (typeof value === 'string') return { type, value }
+  if (Object.prototype.toString.call(value) !== '[object RegExp]') {
+    throw new Error(`${type} should be a string or regex, but got ${value}`)
+  }
   // detox ignores global and sticky state and always uses unicode matching.
   return {
     type,