peachsim 0.1.1620 → 0.1.1625

package/cli/maestro-compare.ts

@@ -455,6 +455,30 @@ export interface CompareSide {
   errors: string[]
 }
 
+// flow verdicts own status; diagnostics do not reject a pass.
+export function buildCompareSide(
+  steps: CompareStep[],
+  outcome: CompareSide['status'],
+  extraErrors: string[],
+  runFailure?: string,
+): CompareSide {
+  const failed = steps.find((step) => step.status === 'failed')
+  const executed = steps.some((step) => step.status !== 'skipped')
+  const errors = [
+    ...(failed ? [`step "${failed.label}" failed: ${failed.error ?? 'no message'}`] : []),
+    ...(runFailure ? [runFailure] : []),
+    ...extraErrors,
+    ...(!executed && outcome !== 'not run' ? ['flow executed no steps'] : []),
+  ]
+  return {
+    status:
+      outcome === 'passed' && (failed || runFailure || !executed) ? 'failed' : outcome,
+    durationMs: steps.reduce((sum, step) => sum + step.durationMs, 0),
+    steps,
+    errors,
+  }
+}
+
 export interface CompareScreen {
   name: string
   step: number

package/cli/outbound-endpoints.ts

@@ -147,7 +147,8 @@ export const OUTBOUND_ENDPOINTS: Record<string, OutboundEndpointDeclaration> = {
   },
   remote_display_server: {
     category: 'explicit-user-action',
-    destination: 'display-server WebSocket URL configured by the embedding host',
+    destination:
+      'display-server WebSocket URL, or scene recording URL, configured by the embedding host',
     preConsent: true,
     payload:
       'display protocol identity, local input events, scroll lifecycle, resync requests, and applied/painted acknowledgements',
@@ -159,13 +160,11 @@ export const OUTBOUND_ENDPOINTS: Record<string, OutboundEndpointDeclaration> = {
     payload: 'preview objects selected by the user for upload',
   },
   // its own entry, deliberately not folded into contrast_user_action. this is
-  // the only egress that sends the CONTENTS of the user's project somewhere,
-  // and to an operator-chosen host rather than a Contrast one, so it must not
-  // be readable as "the usual Contrast call".
+  // the egress that sends the contents of the user's project to a cloud host.
   peach_cloud_box: {
     category: 'explicit-user-action',
     destination:
-      'the Peach Cloud box service named by --endpoint or PEACH_BOX_ENDPOINT; no default, so this call cannot happen unless the user names a host',
+      'the deployed Peach Cloud box service by default, overridden by --endpoint or PEACH_BOX_ENDPOINT',
     preConsent: false,
     payload:
       'every file git reports for the current checkout, then shell commands and file reads and writes for as long as the box shell is open',
@@ -252,6 +251,10 @@ export interface OutboundCallDeclaration {
 // a new fetch, websocket, node HTTP request, or TCP connection has no entry and
 // fails scripts/check/outbound-endpoints.ts until its destination and consent behavior are declared.
 export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> = {
+  'packages/peach-engine/src/launch-metadata.ts :: fetch :: reference': {
+    category: 'local_development',
+    count: 1,
+  },
   'packages/peach-engine/src/engine/barcode-reader.worker.ts :: fetch :: wasmUrl': {
     category: 'same_origin_runtime',
     count: 1,
@@ -282,6 +285,10 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
   // empty, so the request carries no project or app data.
   'packages/peachsim/cli/cloud-client.ts :: fetch :: `${options.apiOrigin}/v1/boxes/${encodeURIComponent()}/display-grant`':
     { category: 'peach_cloud_sim', count: 1 },
+  // a fresh box's boot receipts are read until its page loads or reports an
+  // error; the request carries no body.
+  'packages/peachsim/cli/cloud-client.ts :: fetch :: `${options.apiOrigin}/v1/boxes/${encodeURIComponent()}/lifecycle`':
+    { category: 'peach_cloud_sim', count: 1 },
   // `peach remote` creates through the instance api and lists what it made.
   // the create carries labels and wait=true in the query; the list filters
   // by the remote label.
@@ -379,6 +386,8 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
   'packages/peach-cloud-box/src/browser-run.ts :: fetch :: `https://browser.invalid/v1/devtools/browser/${sessionId}`':
     { category: 'peach_cloud_box', count: 2 },
   // list the account sessions a cloud box is billed against. no project content.
+  "packages/peachsim/cli/remote-simulators.ts :: fetch :: `${account.apiOrigin.replace(/\\/+$/, '')}/api/v1/rnx/sessions?${query}`":
+    { category: 'contrast_user_action', count: 1 },
   "packages/peach-cloud-box/src/client.ts :: fetch :: `${options.apiOrigin.replace(/\\/+$/, '')}/api/v1/rnx/sessions?${search}`":
     { category: 'contrast_user_action', count: 1 },
   // `peach box connect` asks the account service which box that ID or name is
@@ -525,6 +534,8 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
   },
   'packages/peach-engine/src/mcp/ws-bridge.ts :: websocket :: resolveSootsimBridgeWebSocketUrl({ bridgePort, href: window.location.href, })':
     { category: 'local_development', count: 1 },
+  'packages/peach-engine/src/remote-stream/browser-tenant-proxy.ts :: fetch :: this.config.url':
+    { category: 'remote_display_server', count: 1 },
   'packages/peach-engine/src/remote-stream/browser-tenant-proxy.ts :: websocket :: this.config.url':
     { category: 'remote_display_server', count: 1 },
   'packages/peach-engine/src/menu/menuActions.ts :: fetch :: screenshot': {
@@ -612,6 +623,10 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
     category: 'guest_app_network',
     count: 1,
   },
+  'packages/peach-engine/src/render-worker/map-host.ts :: fetch-alias :: request.url': {
+    category: 'guest_app_network',
+    count: 1,
+  },
   'packages/peach-engine/src/render-worker/map-host.ts :: fetch-alias :: url': {
     category: 'map_style_delivery',
     count: 1,
@@ -764,6 +779,8 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
     category: 'local_development',
     count: 1,
   },
+  'packages/peach-engine/src/components/native-ui/ShareSheetView.tsx :: fetch-alias :: `/__fetch-proxy?url=${encodeURIComponent()}`':
+    { category: 'guest_app_network', count: 1 },
   'packages/peachsim/src/dev-bundle-resolution.ts :: fetch :: `/__fetch-proxy?url=${encodeURIComponent()}`':
     { category: 'guest_app_network', count: 1 },
   'packages/peachsim/src/dev-bundle-resolution.ts :: fetch :: targetUrl': {

package/cli/parent-pid.ts

@@ -68,15 +68,6 @@ function buildComm(): CommLookup {
 }
 
 function build(): Lookup {
-  // on any platform, if the shell exports $PPID and it differs from the
-  // node-level process.ppid, it's the shell's own parent — one level up
-  // from where we need to be. this is the cheapest and most portable
-  // grand-ppid source since it needs no subprocess or FFI.
-  const envPpid = Number(process.env.PPID)
-  if (Number.isFinite(envPpid) && envPpid > 1 && envPpid !== process.ppid) {
-    return () => envPpid
-  }
-
   if (process.platform === 'linux') return buildLinux()
   if (process.platform === 'darwin') {
     // on Bun: libproc via FFI is ~0.8µs/call. on Node: one `ps` snapshot of

package/cli/remote-simulators.ts

@@ -0,0 +1,112 @@
+import {
+  cloudBoxConnectUrl,
+  deleteCloudBox,
+  resolveCloudBoxReference,
+} from 'peach-cloud-box/client'
+import { isRecord } from '../src/is-record'
+import { deleteRemoteSim, listRemoteSims } from './cloud-client'
+import type {
+  AccountRemoteSimulator,
+  HostedRemoteSimulator,
+  RemoteSimulatorAccount,
+} from './remoteSimulatorContract'
+
+// the account's meter is the existing index of hosted simulators. shell-only
+// boxes have no simulator session and do not belong in this list.
+async function listHostedSimulators(
+  account: RemoteSimulatorAccount,
+): Promise<HostedRemoteSimulator[]> {
+  const query = new URLSearchParams({ kind: 'sim', status: 'running' })
+  if (account.accountId) query.set('accountId', account.accountId)
+  const response = await fetch(
+    `${account.apiOrigin.replace(/\/+$/, '')}/api/v1/rnx/sessions?${query}`,
+    {
+      headers: { authorization: account.authorization },
+      signal: AbortSignal.timeout(30_000),
+    },
+  )
+  if (!response.ok) {
+    throw new Error(`hosted simulator list ${response.status}: ${await response.text()}`)
+  }
+  const parsed: unknown = await response.json()
+  if (!isRecord(parsed) || !Array.isArray(parsed.sessions)) {
+    throw new Error('hosted simulator list returned invalid JSON')
+  }
+  const sims: HostedRemoteSimulator[] = []
+  for (const session of parsed.sessions) {
+    if (!isRecord(session))
+      throw new Error('hosted simulator list returned an invalid session')
+    if (
+      session.kind !== 'sim' ||
+      session.size !== 'micro' ||
+      session.status !== 'running'
+    )
+      continue
+    if (
+      typeof session.boxId !== 'string' ||
+      !session.boxId ||
+      (session.name !== null && typeof session.name !== 'string') ||
+      (session.device !== null && typeof session.device !== 'string') ||
+      typeof session.startedAt !== 'number' ||
+      !Number.isFinite(session.startedAt) ||
+      typeof session.meteredMs !== 'number' ||
+      !Number.isFinite(session.meteredMs)
+    ) {
+      throw new Error('hosted simulator list returned an invalid simulator')
+    }
+    sims.push({
+      service: 'box',
+      simId: session.boxId,
+      name: session.name,
+      status: 'running',
+      device: session.device,
+      startedAt: session.startedAt,
+      meteredMs: session.meteredMs,
+    })
+  }
+  return sims
+}
+
+export async function listAccountRemoteSimulators(
+  account: RemoteSimulatorAccount,
+): Promise<AccountRemoteSimulator[]> {
+  const [hosted, nano] = await Promise.all([
+    listHostedSimulators(account),
+    listRemoteSims({
+      authorization: account.authorization,
+      accountId: account.accountId,
+    }),
+  ])
+  return [
+    ...hosted,
+    ...nano.map((sim): AccountRemoteSimulator => ({ ...sim, service: 'sim' })),
+  ]
+}
+
+export async function stopAccountRemoteSimulator(
+  account: RemoteSimulatorAccount,
+  simId: string,
+): Promise<{ simId: string } | null> {
+  const hosted = await listHostedSimulators(account)
+  const sim = hosted.find((candidate) => candidate.simId === simId)
+  if (!sim)
+    return deleteRemoteSim({
+      authorization: account.authorization,
+      accountId: account.accountId,
+      simId,
+    })
+
+  // resolve through the account service before addressing a host. another
+  // account's id must never turn into a provider request with this key.
+  const reference = await resolveCloudBoxReference({
+    apiOrigin: account.apiOrigin,
+    apiKey: account.authorization.replace(/^Bearer /, ''),
+    accountId: account.accountId,
+    boxId: sim.simId,
+  })
+  await deleteCloudBox({
+    connectUrl: cloudBoxConnectUrl(reference.endpoint, reference.boxId),
+    accessToken: account.authorization.replace(/^Bearer /, ''),
+  })
+  return { simId: sim.simId }
+}

package/cli/remoteSimulatorContract.ts

@@ -0,0 +1,21 @@
+import type { RnxCloudSimView } from '../src/cloud-contract'
+
+export interface HostedRemoteSimulator {
+  service: 'box'
+  simId: string
+  name: string | null
+  status: 'running'
+  device: string | null
+  startedAt: number
+  meteredMs: number
+}
+
+export type AccountRemoteSimulator =
+  | (RnxCloudSimView & { service: 'sim' })
+  | HostedRemoteSimulator
+
+export interface RemoteSimulatorAccount {
+  apiOrigin: string
+  authorization: string
+  accountId: string | null
+}

package/detox/expectations.ts

@@ -3,6 +3,7 @@
 // waitFor(element).toExist().withTimeout(ms)
 
 import { dragScrollNode } from './gestures'
+import { getSootsimNavigationDiagnostics } from './navigation-lifecycle'
 import type { SootSimElement } from './element-types'
 import type { Matcher } from './matchers'
 import type { SootSimFocusedNodeInfo, SootSimNodeInfo } from '@peach/globals'
@@ -349,7 +350,10 @@ class SootSimWaitForChain {
       const node = await this.findNode(this.matcher)
       const exists = node !== null && node !== undefined
       if (this._negated ? exists : !exists) {
-        throw new Error(`waitFor toExist failed: ${JSON.stringify(this.matcher)}`)
+        // a guest that never mounts leaves its console and page errors only here
+        throw new Error(
+          `waitFor toExist failed: ${JSON.stringify(this.matcher)}\nrecent page diagnostics:\n${JSON.stringify(getSootsimNavigationDiagnostics(this.getPage()))}`,
+        )
       }
     }
     return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage)

package/detox/index.ts

@@ -378,7 +378,7 @@ export async function waitForSootsimShellReady(
 async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<void> {
   const result = await page.evaluate(
     async ({ timeout }) => {
-      const getPeerStats = (window as any).__sootsimTest?.getPeerStats
+      const getPeerStats = window.__sootsimTest?.getPeerStats
       if (typeof getPeerStats !== 'function') {
         return { settled: true, skipped: true }
       }
@@ -387,7 +387,9 @@ async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<v
       const start = Date.now()
       const deadline = start + timeout
       const requiredStableMs = 120
-      let lastPending: number | null = null
+      let lastPending: number | null | undefined = null
+      let completedReads = 0
+      let lastReply: string | null = null
 
       while (Date.now() < deadline) {
         let timer: ReturnType<typeof setTimeout> | undefined
@@ -404,6 +406,8 @@ async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<v
         })
         if (stats === undefined) break
         if (stats === null) return { settled: true, elapsed: Date.now() - start }
+        completedReads++
+        lastReply = JSON.stringify({ elapsedMs: Date.now() - start, stats })
         lastPending = stats.pendingRunWorklets
         // the runtime records its last drain. bridge latency cannot erase an
         // idle interval or turn a missing stats reply into a zero count.
@@ -421,42 +425,80 @@ async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<v
         await sleep(25)
       }
 
-      // no reply at all: ask the shell alone, so a silent tenant and a silent
-      // shell read differently
-      let shellAnswered: boolean | null = null
+      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 shell = (window as any).SootSim?.bridges?.shellHost
-        shellAnswered = shell
-          ? await Promise.race([
-              shell.callTestBridge('getPeerStats', false).then(
-                () => true,
-                () => false,
-              ),
-              sleep(1000).then(() => false),
+        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,
+                )
+              }),
             ])
-          : null
+          } 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,
+        })
       }
       return {
         settled: false,
-        elapsed: Date.now() - start,
+        elapsed: waited,
         pending: lastPending,
-        shellAnswered,
+        realms,
+        observation,
       }
     },
     { timeout },
   )
   if (!result?.settled) {
-    const pending =
-      result?.pending ??
-      `no peer stats reply; shell alone ${
-        result?.shellAnswered == null
-          ? 'has no bridge'
-          : result.shellAnswered
-            ? 'answered within 1000ms'
-            : 'silent for 1000ms'
-      }`
+    const pending = result?.pending ?? `no peer stats reply; ${result?.realms}`
     throw new Error(
-      `sootsim worklet runtime did not settle after ${result?.elapsed ?? timeout}ms (pending=${pending})`,
+      `sootsim worklet runtime did not settle after ${result?.elapsed ?? timeout}ms (pending=${pending}; observation=${JSON.stringify(result?.observation)})`,
     )
   }
 }
@@ -756,67 +798,62 @@ async function nodeOffsetToPage(
   return sootsimToPage(page, center.x + dx, center.y + dy)
 }
 
-async function getDefaultTapPoint(
-  page: Page,
-  nodeInfo: any,
-): Promise<{ x: number; y: number }> {
-  const resolvedTarget = await page.evaluate(
-    (nodeId) => window.__sootsimTest?.resolveTapTarget?.(nodeId) ?? null,
-    nodeInfo.nodeId,
-  )
-  const center =
-    resolvedTarget &&
-    typeof resolvedTarget.cx === 'number' &&
-    typeof resolvedTarget.cy === 'number'
-      ? { x: resolvedTarget.cx, y: resolvedTarget.cy }
-      : getNodeCenter(nodeInfo)
-  const frame = nodeInfo.visibleFrame ?? {
-    x: nodeInfo.absolutePosition?.x ?? nodeInfo.layout?.x ?? 0,
-    y: nodeInfo.absolutePosition?.y ?? nodeInfo.layout?.y ?? 0,
-    width: nodeInfo.layout?.width ?? 0,
-    height: nodeInfo.layout?.height ?? 0,
-  }
-  const viewport = await readSootsimInteractiveViewport(page)
-  const fullFrameTolerance = 0.5
-  // the resolved center is the matched frame's center unless the frame is clipped.
-  const canTapCenter =
-    typeof nodeInfo.absolutePosition?.x === 'number' &&
-    typeof nodeInfo.absolutePosition?.y === 'number' &&
-    typeof nodeInfo.layout?.width === 'number' &&
-    typeof nodeInfo.layout?.height === 'number' &&
-    Math.abs(frame.x - nodeInfo.absolutePosition.x) <= fullFrameTolerance &&
-    Math.abs(frame.y - nodeInfo.absolutePosition.y) <= fullFrameTolerance &&
-    frame.width >= nodeInfo.layout.width - fullFrameTolerance &&
-    frame.height >= nodeInfo.layout.height - fullFrameTolerance &&
-    center.x >= 0 &&
-    center.y >= 0 &&
-    center.x < viewport.width &&
-    center.y < viewport.height
-  if (canTapCenter) return center
-
-  const left = Math.max(0, frame.x)
-  const top = Math.max(0, frame.y)
-  const right = Math.min(viewport.width, frame.x + frame.width)
-  const bottom = Math.min(viewport.height, frame.y + frame.height)
-
-  if (right <= left || bottom <= top) {
-    return center
-  }
-
-  return {
-    x: left + (right - left) / 2,
-    y: top + (bottom - top) / 2,
-  }
-}
+type TapPoint =
+  | { x: number; y: number }
+  | {
+      nodeId: number
+      viewport: { width: number; height: number }
+      offset?: { x?: number; y?: number }
+    }
 
-async function dispatchTapAtSootsimPoint(
-  page: Page,
-  x: number,
-  y: number,
-  token?: string,
-) {
+async function dispatchTapAtSootsimPoint(page: Page, point: TapPoint, token?: string) {
   await page.evaluate(
-    async ({ x, y, token }) => {
+    async ({ point, token }) => {
+      let x: number
+      let y: number
+      if ('nodeId' in point) {
+        // resolve after the viewport read, in the browser task that dispatches
+        // the pointer. a host round trip here can outlive a startup relayout.
+        const resolved = await window.__sootsimTest!.resolveTapTarget(point.nodeId)
+        if (!resolved) throw new Error(`element disappeared before tap: ${point.nodeId}`)
+        const node = resolved.match
+        if (point.offset) {
+          x = node.absolutePosition.x + (point.offset.x ?? node.layout.width / 2)
+          y = node.absolutePosition.y + (point.offset.y ?? node.layout.height / 2)
+        } else {
+          x = resolved.cx
+          y = resolved.cy
+          const frame = node.visibleFrame ?? {
+            x: node.absolutePosition.x,
+            y: node.absolutePosition.y,
+            width: node.layout.width,
+            height: node.layout.height,
+          }
+          const { viewport } = point
+          const tolerance = 0.5
+          const canTapCenter =
+            Math.abs(frame.x - node.absolutePosition.x) <= tolerance &&
+            Math.abs(frame.y - node.absolutePosition.y) <= tolerance &&
+            frame.width >= node.layout.width - tolerance &&
+            frame.height >= node.layout.height - tolerance &&
+            x >= 0 &&
+            y >= 0 &&
+            x < viewport.width &&
+            y < viewport.height
+          if (!canTapCenter) {
+            const left = Math.max(0, frame.x)
+            const top = Math.max(0, frame.y)
+            const right = Math.min(viewport.width, frame.x + frame.width)
+            const bottom = Math.min(viewport.height, frame.y + frame.height)
+            if (right > left && bottom > top) {
+              x = left + (right - left) / 2
+              y = top + (bottom - top) / 2
+            }
+          }
+        }
+      } else {
+        ;({ x, y } = point)
+      }
       const interactTap = window.SootSim?.bridges?.interact?.tap
       if (typeof interactTap === 'function') {
         if (token) window.__sootsimAnchorTimedInput?.(token)
@@ -832,7 +869,7 @@ async function dispatchTapAtSootsimPoint(
       if (token) window.__sootsimAnchorTimedInput?.(token)
       await tap(x, y)
     },
-    { x, y, token },
+    { point, token },
   )
 }
 
@@ -1087,17 +1124,13 @@ function createSootSimElement(matcher: Matcher): SootSimElement {
           `Cannot perform action due to constraint failure: element not visible (${describeNodeVisibility(node)}): ${JSON.stringify(matcher)}`,
         )
       }
-      const defaultPoint = point ? null : await getDefaultTapPoint(page, node)
-      const targetSootSimX =
-        typeof point?.x === 'number'
-          ? node.absolutePosition.x + point.x
-          : (defaultPoint?.x ?? node.absolutePosition.x + node.layout.width / 2)
-      const targetSootSimY =
-        typeof point?.y === 'number'
-          ? node.absolutePosition.y + point.y
-          : (defaultPoint?.y ?? node.absolutePosition.y + node.layout.height / 2)
+      const viewport = await readSootsimInteractiveViewport(page)
       const captureToken = (page as any).__sootsimCaptureToken
-      await dispatchTapAtSootsimPoint(page, targetSootSimX, targetSootSimY, captureToken)
+      await dispatchTapAtSootsimPoint(
+        page,
+        { nodeId: node.nodeId, viewport, offset: point },
+        captureToken,
+      )
       if (_synchronizationEnabled) {
         await waitForSootsimIdle(page)
       }
@@ -1540,8 +1573,10 @@ function createSootSimElement(matcher: Matcher): SootSimElement {
       const captureToken = (page as any).__sootsimCaptureToken
       await dispatchTapAtSootsimPoint(
         page,
-        tapTarget.target.absolutePosition.x + tapTarget.target.layout.width / 2,
-        tapTarget.target.absolutePosition.y + tapTarget.target.layout.height / 2,
+        {
+          x: tapTarget.target.absolutePosition.x + tapTarget.target.layout.width / 2,
+          y: tapTarget.target.absolutePosition.y + tapTarget.target.layout.height / 2,
+        },
         captureToken,
       )
     },

package/detox/motion-change.cjs

@@ -102,6 +102,42 @@ 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
+
+function evaluateMotionTransitions(transitions) {
+  const measured = transitions.every(
+    (transition) =>
+      transition.dimensionsMatch &&
+      transition.changePercent !== null &&
+      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,
+    )
+  return {
+    dense,
+    moving,
+    passed:
+      transitions.length > 0 &&
+      measured &&
+      (dense
+        ? moving >= DENSE_SAMPLE_MINIMUM_MOVING_PAIRS
+        : moving === transitions.length),
+  }
+}
+
 const DISPLAY_LINK_INTERVAL_MS = 1000 / 60
 const DISCRETE_FRAME_TIMING_TOLERANCE_MS = 1000 / 60 + 1000 / 600
 
@@ -361,6 +397,7 @@ module.exports = {
   MOTION_CHANGE_DEFINITION,
   measureMotionChange,
   measureProofMotionChange,
+  evaluateMotionTransitions,
   DISCRETE_FRAME_TIMING_TOLERANCE_MS,
   parseDiscreteFrameCadence,
   classifyDiscreteFrame,

package/detox/motion-change.d.cts

@@ -34,6 +34,22 @@ export function measureProofMotionChange(
   input: Omit<MotionChangeInput, 'definition' | 'installGlobal'>,
 ): MotionChangeMeasurement
 
+export type MotionTransitionSample = {
+  changePercent: number | null
+  changePixels: number | null
+  dimensionsMatch: boolean
+  fromOffsetMs: number
+  passedMinimum: boolean
+  toOffsetMs: number
+  totalPixels: number | null
+}
+
+export function evaluateMotionTransitions(transitions: MotionTransitionSample[]): {
+  dense: boolean
+  moving: number
+  passed: boolean
+}
+
 export type DiscreteFrameAsset = {
   fixturePath: string
   fixtureSha256: string