peachsim 0.1.1644 → 0.1.1653

package/cli/send-to-box.ts

@@ -1,22 +1,18 @@
+import { getCliRuntime } from '../src/cli-runtime.ts'
 // "send to box": the running local app becomes a nano cloud simulator.
 //
 // one function serves both callers. the rail button in the shell reaches it
 // through the local daemon's `/__send-to-box` route, and `peach box send` calls
 // it directly; both hand it a way to run a bridge command against the sim that
 // is running the app, and both get the same simulator id and URL back.
-
-import { isStorageSnapshot } from '../../peach-engine/src/preview/storage-snapshot-contract.ts'
-import {
-  DEFAULT_DEVICE_BY_PLATFORM,
-  getRuntimePlatform,
-  listDeviceModels,
-} from '../../peach-engine/src/settings/devices.ts'
+import { DEFAULT_DEVICE_BY_PLATFORM, listDeviceModels } from '../src/device-catalog.ts'
 import { isRecord } from '../src/is-record'
 import { toPeachProductionBundleUrl } from '../src/metro-production-bundle.ts'
+import { isStorageSnapshot } from '../src/storageSnapshotContract.ts'
+import { StorageSnapshot } from '../src/storageSnapshotContract.ts'
 import { createCloudBox } from './cloud-client.ts'
-import type { StorageSnapshot } from '../../peach-engine/src/preview/storage-snapshot-contract.ts'
-import type { DeviceModel } from '../../peach-engine/src/settings/devices.ts'
 import type { BridgeCommandType } from '../src/bridge-contract.ts'
+import type { DeviceModel } from '../src/device-catalog.ts'
 
 export interface SendToBoxOptions {
   /** runs one bridge command against the sim running the app. */
@@ -49,7 +45,8 @@ export interface SendToBoxResult {
 // iOS only, so an Android sim sends to the default iPhone rather than refusing.
 function cloudDevice(capturedModel: unknown): DeviceModel {
   const captured = listDeviceModels().find((model) => model === capturedModel)
-  return captured && getRuntimePlatform(captured) === 'ios'
+  return captured &&
+    getCliRuntime().settings_devices.getRuntimePlatform(captured) === 'ios'
     ? captured
     : DEFAULT_DEVICE_BY_PLATFORM.ios
 }

package/cli/telemetry.ts

@@ -1,8 +1,8 @@
 import { createHash } from 'node:crypto'
 import { homedir } from 'node:os'
 import { eventUuid } from '@peach/globals/event-identity'
-import { crashFingerprint } from 'peach-engine/crash-fingerprint'
 import { getCliVersion } from '../src/cli-version'
+import { crashFingerprint } from '../src/crash-fingerprint.ts'
 import {
   readActiveRuntime,
   readOrCreateAnonymousId,

package/cli/ws-bridge.ts

@@ -14,6 +14,7 @@ import {
   DEFAULT_SOOTSIM_BRIDGE_PORT,
   resolveSootsimBridgePort,
 } from '../src/bridge-constants'
+import { commandWritesSim, type WsBridgeCommand } from '../src/bridge-contract'
 import { DEFAULT_SOOTSIM_SHELL_URL } from '../src/cli-constants'
 import {
   isDaemonLockfileFresh,
@@ -30,10 +31,10 @@ import {
   getStableOwnerPid,
   readCurrentSim,
   readCurrentSimId,
+  assertNoPendingOpen,
   saveCurrentSimId,
 } from './current-sim'
 import { setPauseAwareTimeout } from './pause-aware-timeout'
-import type { WsBridgeCommand } from '../src/bridge-contract'
 
 // --- bridge world resolution ---------------------------------------------
 //
@@ -805,6 +806,12 @@ export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBrid
         opts.simIdSource === 'flag' ? opts.simId : (readCurrentSimId() ?? opts.simId)
       const targetedSimId =
         typeof cmd.simId === 'string' && cmd.simId ? cmd.simId : sentSimId
+      // an open that has not pinned a sim means the caller's intended target
+      // is not connected. a mutating command with no explicit sim must not
+      // fall to the sole other tab; reads still may.
+      if (!sentSimId && !cmd.simId && (commandWritesSim(cmd) || cmd.type === 'close')) {
+        assertNoPendingOpen()
+      }
       try {
         // a command can itself reload the page and retire its sim id. capture
         // the browser-host lineage before dispatch, while the target still

package/detox/attempt-events.cjs

@@ -1,3 +1,6 @@
+const {
+  parseDiscreteFrameCadence,
+} = require('../../peach-conformance/src/cases/checkpoint-evidence.cjs')
 const fs = require('node:fs')
 const path = require('node:path')
 
@@ -25,7 +28,6 @@ module.exports = { attemptEventsPath, writeAttemptEvent }
 const crypto = require('node:crypto')
 const { spawnSync } = require('node:child_process')
 const {
-  parseDiscreteFrameCadence,
   classifyDiscreteFrame,
   evaluateDiscreteFrameTrace,
 } = require('./motion-change.cjs')

package/detox/attempt-events.d.cts

@@ -1,6 +1,6 @@
+import type { DiscreteFrameCadence } from '../../peach-conformance/src/cases/checkpoint-evidence.cjs'
 import type {
   DiscreteFrameBinding,
-  DiscreteFrameCadence,
   DiscreteFrameDecision,
   DiscreteFrameTrace,
 } from './motion-change.cjs'

package/detox/expectations.ts

@@ -6,7 +6,11 @@ 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'
+import type {
+  PeachAccessibilityNode,
+  SootSimFocusedNodeInfo,
+  SootSimNodeInfo,
+} from '@peach/globals'
 import type { Page } from 'playwright-core'
 
 type FindFn = (matcher: Matcher) => Promise<any>
@@ -121,12 +125,8 @@ class SootSimExpectation {
   }
 
   get not(): SootSimExpectation {
-    return new SootSimExpectation(
-      this.matcher,
-      this.findNode,
-      this.getPage,
-      !this.negated,
-    )
+    this.negated = true
+    return this
   }
 
   async toExist(): Promise<void> {
@@ -141,15 +141,18 @@ class SootSimExpectation {
     } else {
       if (!exists) {
         throw new Error(
-          `expected element to exist but it was not found: ${JSON.stringify(this.matcher)}`,
+          `expected element to exist but it was not found: ${JSON.stringify(this.matcher)}\nrecent page diagnostics:\n${JSON.stringify(getSootsimNavigationDiagnostics(this.getPage()))}`,
         )
       }
     }
   }
 
-  async toBeVisible(): Promise<void> {
+  async toBeVisible(percent = 75): Promise<void> {
     const node = await this.findNode(this.matcher)
-    const visible = isNodeVisible(node)
+    if (!Number.isSafeInteger(percent) || percent < 1 || percent > 100) {
+      throw new Error('`percent` must be an integer between 1 and 100')
+    }
+    const visible = visibleFraction(node) >= percent / 100
     if (this.negated) {
       if (visible) {
         throw new Error(
@@ -166,13 +169,31 @@ class SootSimExpectation {
   }
 
   async toBeNotVisible(): Promise<void> {
-    const node = await this.findNode(this.matcher)
-    const visible = isNodeVisible(node)
-    if (visible) {
-      throw new Error(
-        `expected element NOT to be visible: ${JSON.stringify(this.matcher)}`,
-      )
-    }
+    await this.not.toBeVisible()
+  }
+
+  async toBeNotFocused(): Promise<void> {
+    await this.not.toBeFocused()
+  }
+
+  async toNotExist(): Promise<void> {
+    await this.not.toExist()
+  }
+
+  async toNotHaveText(text: string): Promise<void> {
+    await this.not.toHaveText(text)
+  }
+
+  async toNotHaveLabel(label: string): Promise<void> {
+    await this.not.toHaveLabel(label)
+  }
+
+  async toNotHaveId(id: string): Promise<void> {
+    await this.not.toHaveId(id)
+  }
+
+  async toNotHaveValue(value: string): Promise<void> {
+    await this.not.toHaveValue(value)
   }
 
   async toHaveText(expectedText: string): Promise<void> {
@@ -222,7 +243,7 @@ class SootSimExpectation {
       )
     }
     // check explicit accessibilityLabel, then derived text content
-    const actual = node.accessibilityLabel || node.text || ''
+    const actual = node.accessibilityLabel ?? node.text ?? ''
     const matches = actual === expectedLabel
     if (this.negated) {
       if (matches)
@@ -296,16 +317,25 @@ class SootSimExpectation {
         `element not found for toHaveValue: ${JSON.stringify(this.matcher)}`,
       )
     }
-    // value could be in text or props
-    const actual = node.text || ''
+    const actual = await this.getPage().evaluate(async (nodeId) => {
+      const findValue = (nodes: PeachAccessibilityNode[]): string | null => {
+        for (const candidate of nodes) {
+          if (candidate.nodeId === nodeId) return candidate.value
+          const value = findValue(candidate.children)
+          if (value !== null) return value
+        }
+        return null
+      }
+      return findValue(await window.__sootsimTest!.captureAccessibilityTree())
+    }, node.nodeId)
     if (this.negated) {
-      if (actual.includes(value)) {
+      if (actual === value) {
         throw new Error(
           `expected element NOT to have value "${value}" but got "${actual}"`,
         )
       }
     } else {
-      if (!actual.includes(value)) {
+      if (actual !== value) {
         throw new Error(`expected element to have value "${value}" but got "${actual}"`)
       }
     }
@@ -332,104 +362,79 @@ export function createWaitFor(findNode: FindFn, getPage: GetPageFn) {
 }
 
 class SootSimWaitForChain {
-  private matcher: Matcher
-  private findNode: FindFn
-  private getPage: GetPageFn
-  private assertionFn: (() => Promise<void>) | null = null
-  private _negated = false
+  private expectation: SootSimExpectation
 
-  constructor(matcher: Matcher, findNode: FindFn, getPage: GetPageFn) {
-    this.matcher = matcher
-    this.findNode = findNode
-    this.getPage = getPage
+  constructor(
+    matcher: Matcher,
+    private findNode: FindFn,
+    private getPage: GetPageFn,
+  ) {
+    this.expectation = new SootSimExpectation(matcher, findNode, getPage, false)
   }
 
   get not(): SootSimWaitForChain {
-    this._negated = true
+    this.expectation = this.expectation.not
     return this
   }
 
   toExist(): SootSimWaitForAction {
-    this.assertionFn = async () => {
-      const node = await this.findNode(this.matcher)
-      const exists = node !== null && node !== undefined
-      if (this._negated ? exists : !exists) {
-        // 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)
+    return this.assertion(() => this.expectation.toExist())
   }
 
-  toBeVisible(): SootSimWaitForAction {
-    this.assertionFn = async () => {
-      const node = await this.findNode(this.matcher)
-      const visible = isNodeVisible(node)
-      if (this._negated ? visible : !visible) {
-        throw new Error(
-          `waitFor toBeVisible failed (${describeNodeVisibility(node)}): ${JSON.stringify(this.matcher)}`,
-        )
-      }
-    }
-    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage)
+  toNotExist(): SootSimWaitForAction {
+    return this.not.toExist()
+  }
+
+  toBeVisible(percent?: number): SootSimWaitForAction {
+    return this.assertion(() => this.expectation.toBeVisible(percent))
   }
 
   toBeNotVisible(): SootSimWaitForAction {
-    this.assertionFn = async () => {
-      const node = await this.findNode(this.matcher)
-      const visible = isNodeVisible(node)
-      if (visible) {
-        throw new Error(`waitFor toBeNotVisible failed: ${JSON.stringify(this.matcher)}`)
-      }
-    }
-    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage)
+    return this.not.toBeVisible()
   }
 
-  toHaveText(expectedText: string): SootSimWaitForAction {
-    this.assertionFn = async () => {
-      const node = await this.findNode(this.matcher)
-      if (!node)
-        throw new Error(
-          `waitFor toHaveText: element not found: ${JSON.stringify(this.matcher)}`,
-        )
-      const actual = node.text || ''
-      const matches = actual === expectedText
-      if (this._negated ? matches : !matches) {
-        throw new Error(
-          `waitFor toHaveText: expected "${expectedText}" but got "${actual}" ${JSON.stringify(this.matcher)}`,
-        )
-      }
-    }
-    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage)
+  toHaveText(text: string): SootSimWaitForAction {
+    return this.assertion(() => this.expectation.toHaveText(text))
+  }
+
+  toNotHaveText(text: string): SootSimWaitForAction {
+    return this.not.toHaveText(text)
+  }
+
+  toHaveLabel(label: string): SootSimWaitForAction {
+    return this.assertion(() => this.expectation.toHaveLabel(label))
+  }
+
+  toNotHaveLabel(label: string): SootSimWaitForAction {
+    return this.not.toHaveLabel(label)
+  }
+
+  toHaveId(id: string): SootSimWaitForAction {
+    return this.assertion(() => this.expectation.toHaveId(id))
+  }
+
+  toNotHaveId(id: string): SootSimWaitForAction {
+    return this.not.toHaveId(id)
   }
 
   toHaveValue(value: string): SootSimWaitForAction {
-    this.assertionFn = async () => {
-      const node = await this.findNode(this.matcher)
-      if (!node) throw new Error(`waitFor toHaveValue: element not found`)
-      const actual = node.text || ''
-      if (!actual.includes(value)) {
-        throw new Error(`waitFor toHaveValue: expected "${value}" in "${actual}"`)
-      }
-    }
-    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage)
+    return this.assertion(() => this.expectation.toHaveValue(value))
+  }
+
+  toNotHaveValue(value: string): SootSimWaitForAction {
+    return this.not.toHaveValue(value)
   }
 
   toBeFocused(): SootSimWaitForAction {
-    this.assertionFn = async () => {
-      const node = await this.findNode(this.matcher)
-      if (!node)
-        throw new Error(
-          `waitFor toBeFocused: element not found: ${JSON.stringify(this.matcher)}`,
-        )
-      const focused = await isNodeFocused(node, this.getPage())
-      if (this._negated ? focused : !focused) {
-        throw new Error(`waitFor toBeFocused failed: ${JSON.stringify(this.matcher)}`)
-      }
-    }
-    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage)
+    return this.assertion(() => this.expectation.toBeFocused())
+  }
+
+  toBeNotFocused(): SootSimWaitForAction {
+    return this.not.toBeFocused()
+  }
+
+  private assertion(assertionFn: () => Promise<void>): SootSimWaitForAction {
+    return new SootSimWaitForAction(assertionFn, this.findNode, this.getPage)
   }
 }
 
@@ -445,6 +450,10 @@ class SootSimWaitForAction {
   }
 
   async withTimeout(ms: number): Promise<void> {
+    if (typeof ms !== 'number' || ms < 0) {
+      throw new Error('timeout must be a nonnegative number')
+    }
+    if (ms === 0) return this.assertionFn()
     const start = Date.now()
     const pollInterval = 100
     let lastError: Error | null = null

package/detox/frame-offset.d.mts

@@ -0,0 +1,6 @@
+export function frameIndexForOffset(offsetMs: number, frameIntervalMs: number): number
+export function frameTimingRoundingBound(...operands: number[]): number
+export function stageTouchOffsetMs(
+  touches: ReadonlyArray<{ scheduledMs: number; landedMs: number }> | null | undefined,
+  offsetMs: number,
+): number

package/detox/frame-offset.mjs

@@ -0,0 +1,35 @@
+// ceiling a represented display tick must not advance it by one frame.
+/** @param {number} offsetMs @param {number} frameIntervalMs */
+export function frameIndexForOffset(offsetMs, frameIntervalMs) {
+  if (!Number.isFinite(offsetMs) || offsetMs < 0)
+    throw new Error(`capture: invalid stage offset ${offsetMs}`)
+  if (!Number.isFinite(frameIntervalMs) || frameIntervalMs <= 0)
+    throw new Error(`capture: invalid frame interval ${frameIntervalMs}`)
+  const quotient = offsetMs / frameIntervalMs
+  const nearest = Math.round(quotient)
+  return Math.abs(quotient - nearest) <= Number.EPSILON * Math.abs(quotient)
+    ? nearest
+    : Math.ceil(quotient)
+}
+
+// gamma(2) bounds seconds representation, unit conversion and arithmetic.
+// include original clock operands before subtraction cancels their epoch.
+/** @param {...number} operands */
+export function frameTimingRoundingBound(...operands) {
+  return (
+    (Number.EPSILON / (1 - Number.EPSILON)) *
+    operands.reduce((sum, value) => sum + Math.abs(value), 0)
+  )
+}
+
+// a held trigger replays a touch schedule ({ scheduledMs, landedMs }, both in
+// ms after the first touch). each lane delivers a touch after its schedule, so
+// a stage keeps its time since the last touch scheduled at or before it, and
+// the frame shows the finger state the schedule declares, that long after the
+// finger got there.
+/** @param {Array<{ scheduledMs: number, landedMs: number }> | null | undefined} touches @param {number} offsetMs */
+export function stageTouchOffsetMs(touches, offsetMs) {
+  let last = null
+  for (const touch of touches ?? []) if (touch.scheduledMs <= offsetMs) last = touch
+  return last ? last.landedMs + offsetMs - last.scheduledMs : offsetMs
+}

package/detox/gestures.ts

@@ -1,4 +1,4 @@
-import { scrollTouchSlop } from '../../peach-engine/src/engine/scroll-platform'
+import { getCliRuntime } from '../src/cli-runtime.ts'
 import { pollUntil } from '../src/poll-until'
 // pull in @peach/globals so window.__sootsimTest and
 // window.__sootsimFindInteractiveCanvas are typed inside page.evaluate
@@ -348,7 +348,7 @@ export async function dragScrollNode(
   let endSootSimY = startSootSimY
   // recognition consumes only axis slop. compensate that distance once so
   // excess travel on the first move remains part of the requested scroll.
-  const slop = scrollTouchSlop(DETOX_PLATFORM, 1)
+  const slop = getCliRuntime().engine_scroll_platform.scrollTouchSlop(DETOX_PLATFORM, 1)
   const travel = pixels + slop
 
   switch (direction) {
@@ -381,9 +381,7 @@ export async function dragScrollNode(
     const metrics = await readSootsimPageMetrics(page, 5000)
     const horizontal = direction === 'left' || direction === 'right'
     const startAxis = horizontal ? startSootSimX : startSootSimY
-    const lowerBound = horizontal
-      ? metrics.scrollWindow.left
-      : metrics.scrollWindow.top
+    const lowerBound = horizontal ? metrics.scrollWindow.left : metrics.scrollWindow.top
     const upperBound = horizontal
       ? metrics.scrollWindow.right
       : metrics.scrollWindow.bottom
@@ -403,9 +401,7 @@ export async function dragScrollNode(
         const canvas = window.__sootsimFindInteractiveCanvas?.()
         if (!canvas) throw new Error('peach interactive canvas not found')
         const axisDelta =
-          endPage.x !== startPage.x
-            ? endPage.x - startPage.x
-            : endPage.y - startPage.y
+          endPage.x !== startPage.x ? endPage.x - startPage.x : endPage.y - startPage.y
         const sign = Math.sign(axisDelta)
         const nextFrame = () =>
           new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
@@ -430,11 +426,7 @@ export async function dragScrollNode(
           let strokeRemaining = remaining + 10
           let point = startAxis
           const offsets = [point]
-          while (
-            strokeRemaining > 0 &&
-            point > lowerBound &&
-            point < upperBound
-          ) {
+          while (strokeRemaining > 0 && point > lowerBound && point < upperBound) {
             const delta = Math.min(25, strokeRemaining)
             point += sign * delta
             strokeRemaining -= delta
@@ -540,11 +532,7 @@ export async function dispatchTwoFingerGesture(
       const canvas: HTMLCanvasElement | null =
         window.__sootsimFindInteractiveCanvas?.() ?? document.querySelector('canvas')
       if (!canvas) throw new Error('sootsim interactive canvas not found')
-      const fire = (
-        point: { x: number; y: number },
-        id: number,
-        primary: boolean,
-      ) => {
+      const fire = (point: { x: number; y: number }, id: number, primary: boolean) => {
         canvas.dispatchEvent(
           new PointerEvent('pointerdown', {
             bubbles: true,