peachsim 0.1.1625 → 0.1.1635

package/detox/index.ts

@@ -1,8 +1,7 @@
+import { randomBytes } from 'crypto'
 // detox-compatible test driver for sootsim
 // drop-in replacement for `import { by, device, element, expect, waitFor } from 'detox'`
 // uses playwright to control a headless browser running sootsim
-
-import { randomBytes } from 'crypto'
 import * as fs from 'fs'
 import { execFile } from 'node:child_process'
 import { createRequire } from 'node:module'
@@ -14,6 +13,8 @@ import {
   reserveChromiumAdmission,
   type ChromiumLaunchAdmission,
 } from '../../../scripts/lib/reap-browser'
+import { automateWebAuthenticationSessions } from '../../peach-engine/src/web-authentication-automation-host'
+import type { LockstepInputReceipt, SootSimLockstepFrameReceipt } from '@peach/globals'
 export { reserveChromiumAdmission } from '../../../scripts/lib/reap-browser'
 import {
   readBrowserCompositeCaptureRequest,
@@ -87,10 +88,17 @@ type DiscreteObserverState = {
   finish: () => DiscreteFrameTrace
   close: () => void
 }
+type VisibleChangeCaptureState = {
+  cancelled: boolean
+  ready: boolean
+  triggerStarted: boolean
+  triggerCompleted: boolean
+}
 declare global {
   var __peachChromiumAdmission: ChromiumLaunchAdmission | undefined
   var __peachDetoxCleanup: (() => Promise<void>) | undefined
   interface Window {
+    __sootsimVisibleChangeCaptures?: Record<string, VisibleChangeCaptureState>
     __peachClassifyDiscreteFrame?: typeof classifyDiscreteFrame
     __peachDiscreteObserver?: DiscreteObserverState
   }
@@ -378,7 +386,8 @@ export async function waitForSootsimShellReady(
 async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<void> {
   const result = await page.evaluate(
     async ({ timeout }) => {
-      const getPeerStats = window.__sootsimTest?.getPeerStats
+      const testBridge = window.__sootsimTest
+      const getPeerStats = testBridge?.getPeerStats
       if (typeof getPeerStats !== 'function') {
         return { settled: true, skipped: true }
       }
@@ -390,14 +399,24 @@ async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<v
       let lastPending: number | null | undefined = null
       let completedReads = 0
       let lastReply: string | null = null
+      let readStartedAt: number | null = null
+      let tenantAtRead = window.__sootsimRenderHost
+      let shellAtRead = window.SootSim?.bridges?.shellHost
+      let deadlineTimerLateMs: number | null = null
 
       while (Date.now() < deadline) {
+        readStartedAt = Date.now()
+        tenantAtRead = window.__sootsimRenderHost
+        shellAtRead = window.SootSim?.bridges?.shellHost
         let timer: ReturnType<typeof setTimeout> | undefined
         const stats = await Promise.race([
           getPeerStats(false),
           new Promise<undefined>((resolve) => {
             timer = setTimeout(
-              () => resolve(undefined),
+              () => {
+                deadlineTimerLateMs = Date.now() - deadline
+                resolve(undefined)
+              },
               Math.max(0, deadline - Date.now()),
             )
           }),
@@ -405,6 +424,7 @@ async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<v
           if (timer !== undefined) clearTimeout(timer)
         })
         if (stats === undefined) break
+        readStartedAt = null
         if (stats === null) return { settled: true, elapsed: Date.now() - start }
         completedReads++
         lastReply = JSON.stringify({ elapsedMs: Date.now() - start, stats })
@@ -426,77 +446,44 @@ async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<v
       }
 
       const waited = Date.now() - start
-      // freeze the completed observations before the separate realm probes.
-      // a later reply cannot replace what the original deadline observed.
-      const observation = { completedReads, lastReply }
-      // no reply at all: ask each realm alone, and time this page's own timer,
-      // so a silent tenant, a silent shell and a starved page read differently
-      let realms: string | null = null
-      if (lastPending === null) {
-        const probe = async (bridge: unknown) => {
-          if (
-            !bridge ||
-            typeof bridge !== 'object' ||
-            !('callTestBridge' in bridge) ||
-            typeof bridge.callTestBridge !== 'function'
-          ) {
-            return { status: 'missing-bridge' }
-          }
-          const callTestBridge = bridge.callTestBridge.bind(bridge)
-          const asked = Date.now()
-          let timer: ReturnType<typeof setTimeout> | undefined
-          try {
-            return await Promise.race([
-              Promise.resolve()
-                .then(() => callTestBridge('getPeerStats', false))
-                .then(
-                  (stats) => ({
-                    status: 'answered',
-                    elapsedMs: Date.now() - asked,
-                    stats,
-                  }),
-                  (error: unknown) => ({
-                    status: 'rejected',
-                    elapsedMs: Date.now() - asked,
-                    error: error instanceof Error ? error.message : String(error),
-                  }),
-                ),
-              new Promise<{ status: 'no-reply'; elapsedMs: number }>((resolve) => {
-                timer = setTimeout(
-                  () => resolve({ status: 'no-reply', elapsedMs: Date.now() - asked }),
-                  1000,
-                )
-              }),
-            ])
-          } finally {
-            if (timer !== undefined) clearTimeout(timer)
-          }
-        }
-        const timerAsked = Date.now()
-        const [tenant, shell, pageTimerLateMs] = await Promise.all([
-          probe(window.__sootsimRenderHost),
-          probe(window.SootSim?.bridges?.shellHost),
-          sleep(0).then(() => Date.now() - timerAsked),
-        ])
-        realms = JSON.stringify({
-          phase: 'after-deadline',
-          tenant,
-          shell,
-          pageTimerLateMs,
-        })
+      // snapshot only the original read. a later request cannot explain which
+      // realm delayed this join, and an unchanged host does not prove readiness.
+      const tenantAtDeadline = window.__sootsimRenderHost
+      const shellAtDeadline = window.SootSim?.bridges?.shellHost
+      const observation = {
+        completedReads,
+        lastReply,
+        outstandingRead:
+          readStartedAt === null
+            ? null
+            : {
+                startedAtMs: readStartedAt - start,
+                elapsedMs: Date.now() - readStartedAt,
+                testBridgeChanged: window.__sootsimTest !== testBridge,
+                tenant: {
+                  presentAtRequest: !!tenantAtRead,
+                  presentAtDeadline: !!tenantAtDeadline,
+                  changed: tenantAtRead !== tenantAtDeadline,
+                },
+                shell: {
+                  presentAtRequest: !!shellAtRead,
+                  presentAtDeadline: !!shellAtDeadline,
+                  changed: shellAtRead !== shellAtDeadline,
+                },
+              },
+        deadlineTimerLateMs,
       }
       return {
         settled: false,
         elapsed: waited,
         pending: lastPending,
-        realms,
         observation,
       }
     },
     { timeout },
   )
   if (!result?.settled) {
-    const pending = result?.pending ?? `no peer stats reply; ${result?.realms}`
+    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)})`,
     )
@@ -851,6 +838,31 @@ async function dispatchTapAtSootsimPoint(page: Page, point: TapPoint, token?: st
             }
           }
         }
+        // detox creates the touch in the matched view's window and sends it
+        // through uiapplication, so system status-bar routing cannot take it.
+        // that window's hit test picks the receiver, so a covering view such as
+        // a box-only parent or a pointerEvents none sibling takes the press.
+        if (token) window.__sootsimAnchorTimedInput?.(token)
+        let result = await window.__sootsimTest!.activatePressAt(x, y, point.nodeId)
+        const refusal = result?.tap
+        const covering =
+          refusal &&
+          typeof refusal === 'object' &&
+          'reason' in refusal &&
+          refusal.reason === 'target-covered' &&
+          'coordinateTarget' in refusal
+            ? refusal.coordinateTarget
+            : null
+        if (covering && typeof covering === 'object' && 'nodeId' in covering) {
+          const { nodeId } = covering
+          if (typeof nodeId === 'number') {
+            result = await window.__sootsimTest!.activatePressAt(x, y, nodeId)
+          }
+        }
+        if (result?.ok !== true) {
+          throw new Error(`element tap was refused: ${JSON.stringify(result)}`)
+        }
+        return
       } else {
         ;({ x, y } = point)
       }
@@ -1673,18 +1685,20 @@ function createSootSimElement(matcher: Matcher): SootSimElement {
         visible: node.layout.width > 0 && node.layout.height > 0,
         enabled: !node.accessibilityState?.disabled,
         ...node,
-        // the transformed rect when the node reports one; a node resolved
-        // without a size (x and y only) keeps its own frame
+        // native detox reads a gauge's accessibility path, which excludes
+        // the empty space below an accessory arc. keep other frame contracts.
         frame:
-          node.absolutePosition?.width !== undefined &&
-          node.absolutePosition.height !== undefined
-            ? {
-                x: node.absolutePosition.x,
-                y: node.absolutePosition.y,
-                width: node.absolutePosition.width,
-                height: node.absolutePosition.height,
-              }
-            : node.frame,
+          node.nativeType === 'ExpoUI_GaugeView' && node.accessibilityFrame
+            ? node.accessibilityFrame
+            : node.absolutePosition?.width !== undefined &&
+                node.absolutePosition.height !== undefined
+              ? {
+                  x: node.absolutePosition.x,
+                  y: node.absolutePosition.y,
+                  width: node.absolutePosition.width,
+                  height: node.absolutePosition.height,
+                }
+              : node.frame,
       })
       // detox reads an unindexed pattern that selects several elements as a list
       if (matcher.regexFlags !== undefined && matcher.index === undefined) {
@@ -2019,6 +2033,12 @@ export const device = {
         reapOwnedBrowser()
         throw error
       }
+      await automateWebAuthenticationSessions(
+        _context!,
+        '__peachWebAuthenticationHost',
+        _page,
+        false,
+      )
       contextIdentity = newContextIdentity
     }
 
@@ -2600,9 +2620,7 @@ export const device = {
       frame?: { height: number; width: number; x: number; y: number } | null
       // a pointer the capture itself presses at the trigger point and releases
       // once durationMs of lockstep time has elapsed, so held states (a lifted
-      // control thumb, a pressed row) are painted mid-hold. an external trigger
-      // that holds and releases before returning never paints a frame in
-      // between, because no lockstep frame steps while it runs. moves drag the
+      // control thumb, a pressed row) are painted mid-hold. moves drag the
       // held pointer to each point once afterMs of lockstep time has elapsed
       // since the press, and the release lands at the last point reached.
       hold?: {
@@ -2611,11 +2629,16 @@ export const device = {
         x: number
         y: number
       } | null
+      // stages measure from the frame that delivers the hold's release rather
+      // than from the first visible change, the delivered touch-up anchor the
+      // native lane uses.
+      anchorAtRelease?: boolean
       rootFrame?: { height: number; width: number; x: number; y: number } | null
       settleMs?: number
       trigger?: () => unknown
     },
   ): Promise<{
+    inputReceipts: LockstepInputReceipt[]
     anchors: Array<{
       changedPixelPercent: number
       frameIndex: number
@@ -2659,6 +2682,7 @@ export const device = {
       installGlobal: true,
     })
     const capturePromise: Promise<{
+      inputReceipts: LockstepInputReceipt[]
       anchors: Array<{
         changedPixelPercent: number
         frameIndex: number
@@ -2686,12 +2710,6 @@ export const device = {
       }
     }> = page.evaluate(
       async (input) => {
-        type FrameReceipt = { frameIndex: number; virtualTimestampMs: number }
-        type CaptureState = {
-          cancelled: boolean
-          ready: boolean
-          triggerCompleted: boolean
-        }
         type CaptureWindow = Window & {
           __sootsimMeasureMotionChange?: (input: {
             baseline: Uint8ClampedArray
@@ -2701,7 +2719,6 @@ export const device = {
             label: string
             width: number
           }) => MotionChangeMeasurement
-          __sootsimVisibleChangeCaptures?: Record<string, CaptureState>
           SootSim?: {
             bridges?: {
               interact?: Required<
@@ -2713,19 +2730,6 @@ export const device = {
                   frameToken: number
                 }>
               }
-              lockstepCapture?: {
-                begin: (fps: number) => Promise<{
-                  readonly initialFrame: FrameReceipt
-                  flushFrame: () => Promise<FrameReceipt>
-                  stepFrame: () => Promise<FrameReceipt>
-                  framesForOffset: (offsetMs: number) => number
-                  stepToOffset: (
-                    anchor: FrameReceipt,
-                    offsetMs: number,
-                  ) => Promise<FrameReceipt>
-                  end: () => void
-                }>
-              }
             }
           }
         }
@@ -2751,9 +2755,10 @@ export const device = {
         const registry =
           captureWindow.__sootsimVisibleChangeCaptures ??
           (captureWindow.__sootsimVisibleChangeCaptures = {})
-        const state: CaptureState = {
+        const state: VisibleChangeCaptureState = {
           cancelled: false,
           ready: false,
+          triggerStarted: false,
           triggerCompleted: false,
         }
         registry[input.token] = state
@@ -2848,6 +2853,7 @@ export const device = {
         const holdState = {
           nextMove: 0,
           pressFrameIndex: null as number | null,
+          releaseReceipt: null as SootSimLockstepFrameReceipt | null,
           released: false,
           x: input.hold?.x ?? 0,
           y: input.hold?.y ?? 0,
@@ -2861,7 +2867,7 @@ export const device = {
           const move = moves[holdState.nextMove]
           return holdEventFrameIndex(move ? move.afterMs : input.hold.durationMs)
         }
-        const advanceHold = async (receipt: FrameReceipt) => {
+        const advanceHold = async (receipt: SootSimLockstepFrameReceipt) => {
           if (!input.hold || !interact || holdState.released) return
           if (holdState.pressFrameIndex === null) {
             holdState.pressFrameIndex = receipt.frameIndex - 1
@@ -2885,6 +2891,7 @@ export const device = {
           }
           if (receipt.frameIndex < holdEventFrameIndex(input.hold.durationMs)) return
           holdState.released = true
+          holdState.releaseReceipt = receipt
           await interact.touchUp(
             holdState.x,
             holdState.y,
@@ -2913,13 +2920,13 @@ export const device = {
               )
             }
           } else {
-            while (!state.triggerCompleted) {
+            while (!state.triggerStarted) {
               if (state.cancelled) throw new Error('peach motion capture was cancelled')
               await new Promise((resolve) => setTimeout(resolve, 0))
             }
           }
 
-          let visibleStart: FrameReceipt | null = null
+          let visibleStart: SootSimLockstepFrameReceipt | null = null
           let detectedMeasurement: MotionChangeMeasurement | null = null
           let previousBitmap: ImageBitmap | null = null
           // android can publish mount layout at p=0 before a clock step.
@@ -2951,6 +2958,10 @@ export const device = {
             const receipt = await controller.stepFrame()
             await advanceHold(receipt)
             const candidateBitmap = await captureBitmap()
+            // a release anchor's frame may precede the first visible change
+            if (input.anchorAtRelease && holdState.releaseReceipt === receipt) {
+              keptFrames.set(receipt.frameIndex, await createImageBitmap(candidateBitmap))
+            }
             const bounds = boundsFor(candidateBitmap)
             const measurement = measureChange({
               baseline,
@@ -2965,6 +2976,7 @@ export const device = {
               previousBitmap = null
               visibleStart = receipt
               detectedMeasurement = measurement
+              keptFrames.get(receipt.frameIndex)?.close()
               keptFrames.set(receipt.frameIndex, candidateBitmap)
               break
             }
@@ -2980,10 +2992,29 @@ export const device = {
           // 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.
-          const driveStart = visibleStart
+          // preceding tick is still baseline on both legs. a release anchor
+          // instead starts the drive at the frame that delivers the touch-up.
+          let driveStart = visibleStart
           let currentReceipt = visibleStart
-          const resolvedAnchors = new Map<string, FrameReceipt>()
+          if (input.anchorAtRelease) {
+            if (!input.hold) {
+              throw new Error('peach release anchoring needs a hold')
+            }
+            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.releaseReceipt) {
+              throw new Error('peach release anchoring found no release frame')
+            }
+            driveStart = holdState.releaseReceipt
+          }
+          const resolvedAnchors = new Map<string, SootSimLockstepFrameReceipt>()
           const anchorRecords: Array<{
             changedPixelPercent: number
             frameIndex: number
@@ -2997,7 +3028,7 @@ export const device = {
           const resolveAnchor = async (stage: {
             label: string
             anchor?: { id: string; notBeforeMs: number; onsetThresholdPercent?: number }
-          }): Promise<{ anchorId: string; receipt: FrameReceipt }> => {
+          }): Promise<{ anchorId: string; receipt: SootSimLockstepFrameReceipt }> => {
             const anchor = stage.anchor
             if (!anchor) return { anchorId: 'transition', receipt: driveStart }
             const known = resolvedAnchors.get(anchor.id)
@@ -3153,7 +3184,13 @@ export const device = {
             )
             await controller.stepToOffset(driveStart, maximumPrimaryMs + input.settleMs)
           }
+          while (!state.triggerCompleted) {
+            if (state.cancelled) throw new Error('peach motion capture was cancelled')
+            await controller.stepFrame()
+            await new Promise((resolve) => setTimeout(resolve, 0))
+          }
           return {
+            inputReceipts: controller.inputReceipts,
             anchors: anchorRecords,
             driveStart: {
               frameIndex: driveStart.frameIndex,
@@ -3180,6 +3217,7 @@ export const device = {
       {
         detectionTimeoutMs: options.detectionTimeoutMs ?? 3000,
         frame: options.frame ?? null,
+        anchorAtRelease: options.anchorAtRelease ?? false,
         hold: options.hold ?? null,
         motionChangeDefinition: MOTION_CHANGE_DEFINITION,
         platform: device.getPlatform(),
@@ -3192,14 +3230,7 @@ export const device = {
 
     await page.waitForFunction(
       (captureToken) => {
-        const registry = (
-          window as Window & {
-            __sootsimVisibleChangeCaptures?: Record<
-              string,
-              { cancelled: boolean; ready: boolean; triggerCompleted: boolean }
-            >
-          }
-        ).__sootsimVisibleChangeCaptures
+        const registry = window.__sootsimVisibleChangeCaptures
         return registry?.[captureToken]?.ready === true
       },
       token,
@@ -3209,28 +3240,29 @@ export const device = {
     const triggerStartMs = Date.now()
     let triggerCompletedMs = 0
     try {
-      if (!options.hold) {
-        if (typeof options.trigger !== 'function') {
-          throw new Error('peach motion capture needs a trigger or a hold')
-        }
-        await Promise.resolve(options.trigger())
-      }
-      triggerCompletedMs = Date.now()
-      await page.evaluate((captureToken) => {
-        const registry = (
-          window as Window & {
-            __sootsimVisibleChangeCaptures?: Record<
-              string,
-              { cancelled: boolean; ready: boolean; triggerCompleted: boolean }
-            >
+      const triggerPromise = (async () => {
+        if (!options.hold) {
+          if (typeof options.trigger !== 'function') {
+            throw new Error('peach motion capture needs a trigger or a hold')
           }
-        ).__sootsimVisibleChangeCaptures
-        const capture = registry?.[captureToken]
-        if (!capture) throw new Error('peach motion capture disarmed before trigger')
-        capture.triggerCompleted = true
-      }, token)
-      const capture = await capturePromise
+          const triggered = Promise.resolve().then(options.trigger)
+          await page.evaluate((captureToken) => {
+            const capture = window.__sootsimVisibleChangeCaptures?.[captureToken]
+            if (!capture) throw new Error('peach motion capture disarmed before trigger')
+            capture.triggerStarted = true
+          }, token)
+          await triggered
+        }
+        triggerCompletedMs = Date.now()
+        await page.evaluate((captureToken) => {
+          const capture = window.__sootsimVisibleChangeCaptures?.[captureToken]
+          if (!capture) throw new Error('peach motion capture disarmed before trigger')
+          capture.triggerCompleted = true
+        }, token)
+      })()
+      const [capture] = await Promise.all([capturePromise, triggerPromise])
       return {
+        inputReceipts: capture.inputReceipts,
         anchors: capture.anchors,
         driveStart: capture.driveStart,
         frames: writeFastScreenshotFrames(namePrefix, capture.frames),
@@ -3245,14 +3277,7 @@ export const device = {
     } catch (error) {
       await page
         .evaluate((captureToken) => {
-          const registry = (
-            window as Window & {
-              __sootsimVisibleChangeCaptures?: Record<
-                string,
-                { cancelled: boolean; ready: boolean; triggerCompleted: boolean }
-              >
-            }
-          ).__sootsimVisibleChangeCaptures
+          const registry = window.__sootsimVisibleChangeCaptures
           const capture = registry?.[captureToken]
           if (capture) capture.cancelled = true
         }, token)

package/detox/motion-change.cjs

@@ -102,16 +102,34 @@ function measureProofMotionChange(input) {
   })
 }
 
-// a target sampled at every display frame (each gap at most one 60fps interval)
-// legitimately includes held input and settled frames whose pairs show no
-// change. such a sequence proves motion only when at least six pairs (100ms of
-// display frames) clear the minimum: a one-frame flash moves two pairs and a
-// static capture none, and both fail. a sparser sequence samples distinct
-// stages, so each pair must clear it.
-const DENSE_SAMPLE_MAX_GAP_MS = 1000 / 60 + 1
-const DENSE_SAMPLE_MINIMUM_MOVING_PAIRS = 6
+// native recordings drift 0.1% to 0.2% between real changes where sootsim holds
+// exactly still, so only oracle changes of at least this much need a sootsim
+// match.
+const PAIRED_MOTION_MINIMUM_CHANGE_PERCENT = 0.3
+// a lone change below this after a still transition is a settle blip, which
+// the two targets land a frame or two apart, so it needs no match.
+const SETTLE_BLIP_MAXIMUM_CHANGE_PERCENT = 0.6
 
-function evaluateMotionTransitions(transitions) {
+// a present or dismiss records one second (60 transitions); a gesture ladder
+// records four. a gesture jumps at its touch cadence and each capture phases
+// that cadence differently, so a gesture is graded by total travel instead of
+// by frame, and the native driver plays the finger path up to ten frames ahead
+// of the sootsim one, so the whole gesture's travel is judged, not its timing.
+const GESTURE_MOTION_MIN_TRANSITIONS = 120
+const GESTURE_TRAVEL_RATIO_RANGE = Object.freeze({ min: 0.8, max: 1.25 })
+
+// a sampled motion proves movement as a pair: the oracle moves in at least one
+// transition. a one second motion also needs sootsim to move within one frame
+// of every transition where the oracle changed by the paired minimum; a hold
+// where the oracle holds needs no sootsim movement, while a static sootsim
+// against a moving oracle fails. a gesture needs sootsim's total travel within
+// a range of the oracle's. transitions pair by their stage labels; every
+// measurement must exist.
+function evaluateMotionTransitions(transitions, oracleTarget) {
+  const key = (transition) => `${transition.fromLabel}\u0000${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 measured = transitions.every(
     (transition) =>
       transition.dimensionsMatch &&
@@ -119,22 +137,40 @@ function evaluateMotionTransitions(transitions) {
       transition.changePixels !== null &&
       transition.totalPixels !== null,
   )
-  const moving = transitions.filter((transition) => transition.passedMinimum).length
-  const dense =
-    transitions.length > DENSE_SAMPLE_MINIMUM_MOVING_PAIRS &&
-    transitions.every(
-      (transition) =>
-        transition.toOffsetMs - transition.fromOffsetMs <= DENSE_SAMPLE_MAX_GAP_MS,
+  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 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)),
+        )
   return {
-    dense,
-    moving,
+    moving: moving.length,
     passed:
-      transitions.length > 0 &&
       measured &&
-      (dense
-        ? moving >= DENSE_SAMPLE_MINIMUM_MOVING_PAIRS
-        : moving === transitions.length),
+      oracle.length > 0 &&
+      sootsim.length === oracle.length &&
+      moving.length > 0 &&
+      follows,
   }
 }
 

package/detox/motion-change.d.cts

@@ -35,6 +35,9 @@ export function measureProofMotionChange(
 ): MotionChangeMeasurement
 
 export type MotionTransitionSample = {
+  fromLabel: string
+  toLabel: string
+  target: string
   changePercent: number | null
   changePixels: number | null
   dimensionsMatch: boolean
@@ -44,8 +47,10 @@ export type MotionTransitionSample = {
   totalPixels: number | null
 }
 
-export function evaluateMotionTransitions(transitions: MotionTransitionSample[]): {
-  dense: boolean
+export function evaluateMotionTransitions(
+  transitions: MotionTransitionSample[],
+  oracleTarget: string,
+): {
   moving: number
   passed: boolean
 }