peachsim 0.1.1625 → 0.1.1635

package/cli/maestro-compare.ts

@@ -121,8 +121,8 @@ function absolutizeRefs(steps: unknown, flowDir: string): unknown {
   })
 }
 
-// insert one capture after every screen-changing top-level step. subflows run
-// as one step and are captured once, after they return.
+// insert maestro's pixel-stillness wait before each checkpoint on both sides.
+// subflows run as one step and are captured once, after they return.
 export function instrumentFlowSource(
   source: string,
   flowDir: string,
@@ -159,6 +159,7 @@ export function instrumentFlowSource(
     const label = stepLabel(step)
     const name = `${COMPARE_SHOT_DIR}/${String(captures.length + 1).padStart(3, '0')}-${slugify(label)}`
     captures.push({ name, step: index + 1, label })
+    out.push('waitForAnimationToEnd')
     out.push({ takeScreenshot: name })
   }
   // maestro reads flows as yaml 1.1, where a bare yes, no, on or off is a
@@ -280,14 +281,52 @@ export function nativeStepsFromCommandsJson(json: unknown): CompareStep[] {
   return steps
 }
 
-export function nativeFlowFailureFromLog(log: string, name: string): string | undefined {
-  const verdict = `[Failed] ${name}`
-  return log.split(/[\r\n]+/).some((line) => {
-    const text = line.trim()
-    return text === verdict || text.startsWith(`${verdict} (`)
+const XML_ENTITIES: Record<string, string> = {
+  amp: '&',
+  lt: '<',
+  gt: '>',
+  quot: '"',
+  apos: "'",
+}
+
+function decodeXml(text: string): string {
+  return text.replace(/&(?:#(\d+)|#x([\da-f]+)|(\w+));/gi, (match, dec, hex, name) => {
+    if (dec || hex) return String.fromCodePoint(parseInt(dec ?? hex, dec ? 10 : 16))
+    return XML_ENTITIES[name] ?? match
   })
-    ? 'Maestro reported this flow failed; see ios.log'
-    : undefined
+}
+
+export function junitFlowKey(name: string, fileStem: string): string {
+  return JSON.stringify([name, fileStem])
+}
+
+// maestro's own per-flow report (--format junit): one testcase per flow, whose
+// status and failure text are the verdict whatever the flow did or printed.
+// values hold the failure message per testcase, undefined for a pass, in
+// report order so flows that share a name and file stem pair in run order.
+export function nativeFlowVerdictsFromJunit(
+  xml: string,
+): Map<string, Array<string | undefined>> {
+  const verdicts = new Map<string, Array<string | undefined>>()
+  for (const match of xml.matchAll(/<testcase\b([^>]*?)(\/>|>([\s\S]*?)<\/testcase>)/g)) {
+    const attrs = new Map<string, string>()
+    for (const attr of (match[1] ?? '').matchAll(/([\w:-]+)="([^"]*)"/g)) {
+      attrs.set(attr[1]!, decodeXml(attr[2]!))
+    }
+    const file = attrs.get('file')
+    const name = attrs.get('name')
+    if (file === undefined || name === undefined) continue
+    const body = match[3] ?? ''
+    const failure =
+      /<(?:failure|error)\b[^>]*?(?:\/>|>([\s\S]*?)<\/(?:failure|error)>)/.exec(body)
+    const failed = failure !== null || attrs.get('status') === 'ERROR'
+    const message = failure?.[1] ? decodeXml(failure[1]).trim() : ''
+    const key = junitFlowKey(name, path.basename(file).replace(/\.(ya?ml)$/i, ''))
+    const list = verdicts.get(key) ?? []
+    list.push(failed ? `Maestro failed this flow: ${message || 'no message'}` : undefined)
+    verdicts.set(key, list)
+  }
+  return verdicts
 }
 
 // peach's commands.json (maestro-report.ts buildFlowCommandsJson)
@@ -325,6 +364,30 @@ export interface ScreenDiff {
   maskedTopPx: number
 }
 
+// captures of one framebuffer can differ by a column or row: maestro's xctest
+// shot drops the rightmost column of an odd framebuffer. such a pair is scored
+// on the top-left area both have, with no resampling, which would shift every
+// edge. null when the sizes match or differ by more than one pixel.
+export function commonAreaSize(
+  a: { width: number; height: number },
+  b: { width: number; height: number },
+): { width: number; height: number } | null {
+  const dw = Math.abs(a.width - b.width)
+  const dh = Math.abs(a.height - b.height)
+  if ((dw === 0 && dh === 0) || dw > 1 || dh > 1) return null
+  return { width: Math.min(a.width, b.width), height: Math.min(a.height, b.height) }
+}
+
+function cropTopLeft(src: PNG, width: number, height: number): PNG {
+  if (src.width === width && src.height === height) return src
+  const out = new PNG({ width, height })
+  for (let y = 0; y < height; y++) {
+    const from = y * src.width * 4
+    src.data.copy(out.data, y * width * 4, from, from + width * 4)
+  }
+  return out
+}
+
 function resample(src: PNG, width: number, height: number): PNG {
   const out = new PNG({ width, height })
   const sx = src.width / width
@@ -402,8 +465,13 @@ export function compareScreens(
   peachPng: Buffer,
   opts: { maskTopPx?: number } = {},
 ): { diff: ScreenDiff; triptych: Buffer } {
-  const native = PNG.sync.read(nativePng)
+  let native: PNG = PNG.sync.read(nativePng)
   let peach: PNG = PNG.sync.read(peachPng)
+  const common = commonAreaSize(native, peach)
+  if (common) {
+    native = cropTopLeft(native, common.width, common.height)
+    peach = cropTopLeft(peach, common.width, common.height)
+  }
   const { width, height } = native
   const aspectMismatch = Math.abs(peach.width / peach.height - width / height) > 0.01
   const resized = peach.width !== width || peach.height !== height
@@ -602,10 +670,14 @@ function screenCard(screen: CompareScreen, threshold: number, flowIndex: number)
   ].filter(Boolean)
   let body = ''
   if (screen.image) {
+    const imageUrl = screen.image.split('/').map(encodeURIComponent).join('/')
     body = `<div class="cols"><span>iOS simulator</span><span>Peach</span><span>pixel diff</span></div>
-<a href="${esc(screen.image)}" target="_blank"><img loading="lazy" src="${esc(screen.image)}" alt="${esc(screen.label)}"></a>`
+<a href="${esc(imageUrl)}" target="_blank"><img loading="lazy" src="${esc(imageUrl)}" alt="${esc(screen.label)}"></a>`
   } else {
-    const only = screen.nativeOnly ?? screen.peachOnly
+    const only = (screen.nativeOnly ?? screen.peachOnly)
+      ?.split('/')
+      .map(encodeURIComponent)
+      .join('/')
     body = only
       ? `<div class="cols one"><span>${screen.nativeOnly ? 'iOS simulator' : 'Peach'} only</span></div><a href="${esc(only)}" target="_blank"><img class="single" loading="lazy" src="${esc(only)}" alt="${esc(screen.label)}"></a>`
       : '<p class="quiet">Neither side reached this step.</p>'

package/cli/main.ts

@@ -63,7 +63,8 @@ async function handleTopLevelError(err: unknown): Promise<never> {
     msg.startsWith(
       `package.json already defines scripts.${rnxPublicBrand.commandName} as `,
     ) ||
-    msg.startsWith('could not resolve a native bundle for ')
+    msg.startsWith('could not resolve a native bundle for ') ||
+    msg.startsWith('could not load ')
   if (isKnownCliFailure && !process.env.SOOTSIM_VERBOSE) {
     process.stderr.write(`  ${msg}\n`)
     await exitWithFlushedOutput(1)

package/cli/outbound-endpoints.ts

@@ -491,7 +491,7 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
   },
   'packages/peach-engine/src/engine/lottie-runtime.ts :: fetch :: descriptor.value': {
     category: 'guest_app_network',
-    count: 2,
+    count: 1,
   },
   'packages/peach-engine/src/bundle-fetch.ts :: fetch-alias :: buildBrowserAssetProxyUrl(devServerUrl)':
     { category: 'guest_app_network', count: 1 },
@@ -673,6 +673,14 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
       category: 'local_development',
       count: 1,
     },
+  'packages/peachsim/cli/commands/control.ts :: net.connect :: port': {
+    category: 'local_development',
+    count: 1,
+  },
+  'packages/peachsim/cli/commands/control.ts :: fetch :: origin': {
+    category: 'local_development',
+    count: 1,
+  },
   'packages/peachsim/cli/commands/control.ts :: websocket :: `ws://127.0.0.1:${port}`': {
     category: 'local_development',
     count: 1,
@@ -805,6 +813,10 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
     category: 'local_development',
     count: 1,
   },
+  'packages/peachsim/src/expo-swift-ready.ts :: fetch :: endpointUrl': {
+    category: 'local_development',
+    count: 1,
+  },
   'packages/peach-engine/src/expo-swift-compilation.ts :: fetch-alias :: address': {
     category: 'local_development',
     count: 1,

package/cli/pause-aware-timeout.ts

@@ -0,0 +1,102 @@
+import { execFileSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+// the team machine load governor SIGSTOPs a job and records its pids in this
+// ledger (`{ [rootPid]: [{ pid, started_at_ms }] }`, `{}` when nothing is
+// held) until it resumes them. a plain setTimeout keeps running across that
+// hold, so a command the paused browser could not answer times out for load
+// it never caused. a deadline only stops advancing while the pid it waits on
+// is held; a dead or unrelated process never extends it.
+const LEDGER_PATH = path.join(
+  process.env.TM_HOME || path.join(os.homedir(), '.team-machine'),
+  'governor-pauses.json',
+)
+const TICK_MS = 500
+
+interface Timer {
+  hostPid: number
+  remaining: number
+  accountedAt: number
+  fire: () => void
+}
+
+const timers = new Set<Timer>()
+let poll: ReturnType<typeof setInterval> | undefined
+
+function pausedPids(): number[] {
+  try {
+    const ledger: Record<string, { pid: number }[]> = JSON.parse(
+      readFileSync(LEDGER_PATH, 'utf8'),
+    )
+    return Object.values(ledger).flatMap((procs) => procs.map((proc) => proc.pid))
+  } catch {
+    return []
+  }
+}
+
+// the pids in `paused` that are `rootPid` or descend from it, by ps ancestry.
+function heldRoots(paused: number[], roots: Set<number>): Set<number> {
+  const parents = new Map<number, number>()
+  for (const line of execFileSync('ps', ['-A', '-o', 'pid=,ppid='], {
+    encoding: 'utf8',
+  }).split('\n')) {
+    const [pid, ppid] = line.trim().split(/\s+/).map(Number)
+    if (pid && ppid !== undefined) parents.set(pid, ppid)
+  }
+  const held = new Set<number>()
+  for (const start of paused) {
+    for (let pid: number | undefined = start, hops = 0; pid && hops < 64; hops++) {
+      if (roots.has(pid)) {
+        held.add(pid)
+        break
+      }
+      pid = parents.get(pid)
+    }
+  }
+  return held
+}
+
+function tick() {
+  const now = Date.now()
+  const paused = pausedPids()
+  const held = paused.length
+    ? heldRoots(paused, new Set([...timers].map((timer) => timer.hostPid)))
+    : new Set<number>()
+  for (const timer of [...timers]) {
+    // each timer accounts only since its own creation or last accounting
+    if (!held.has(timer.hostPid)) timer.remaining -= now - timer.accountedAt
+    timer.accountedAt = now
+    if (timer.remaining <= 0) {
+      timers.delete(timer)
+      timer.fire()
+    }
+  }
+  if (timers.size === 0 && poll) {
+    clearInterval(poll)
+    poll = undefined
+  }
+}
+
+// like setTimeout, but the budget does not advance while the governor holds
+// `hostPid` (the browser host the command waits on) or a descendant paused.
+// one shared poll serves every timer. returns the clear function.
+export function setPauseAwareTimeout(
+  fn: () => void,
+  budgetMs: number,
+  hostPid: number | undefined,
+): () => void {
+  if (hostPid === undefined) {
+    const timer = setTimeout(fn, budgetMs)
+    return () => clearTimeout(timer)
+  }
+  const timer: Timer = { hostPid, remaining: budgetMs, accountedAt: Date.now(), fire: fn }
+  timers.add(timer)
+  if (!poll) {
+    poll = setInterval(tick, TICK_MS)
+  }
+  return () => {
+    timers.delete(timer)
+  }
+}

package/cli/scene-video.ts

@@ -0,0 +1,89 @@
+import { writeFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { readSceneRecordingUpload } from 'peach-engine/remote-stream/scene-recording'
+import { launchReapedChrome } from '../../../scripts/lib/reap-browser'
+import {
+  ensurePlaywrightBrowser,
+  provisionPlaywright,
+} from './drivers/playwright-provisioning'
+
+// render the saved display stream in an isolated viewer. guest code never runs,
+// and capture time is independent of the machine that recorded the app.
+export async function renderSceneToVideo(options: {
+  scene: Uint8Array
+  shellUrl: string
+  output: string
+}): Promise<{
+  durationMs: number
+  frameCount: number
+  renderTimeMs: number
+  sizeBytes: number
+}> {
+  const { header } = await readSceneRecordingUpload(options.scene)
+  const resolved = await provisionPlaywright()
+  const installed = await ensurePlaywrightBrowser(resolved, true)
+  if (!installed.ok) throw new Error(installed.message)
+  const require = createRequire(import.meta.url)
+  const { chromium }: typeof import('playwright-core') = require(resolved.modulePath)
+  const browser = await launchReapedChrome((opts) => chromium.launch(opts), {
+    headless: true,
+    ...(installed.libraryPath
+      ? { env: { ...process.env, LD_LIBRARY_PATH: installed.libraryPath } }
+      : {}),
+  })
+  try {
+    const source = new URL(options.shellUrl)
+    const url = new URL(source.pathname, source.origin)
+    url.searchParams.set('device', header.peer.deviceProfile)
+    url.searchParams.set('colorScheme', header.peer.appearance)
+    for (const key of ['orientation']) {
+      const value = source.searchParams.get(key)
+      if (value) url.searchParams.set(key, value)
+    }
+    const sceneUrl = new URL('__scene_export.psr.gz', url).href
+    const page = await browser.newPage({
+      viewport: { width: 600, height: 1000 },
+      deviceScaleFactor: 3,
+    })
+    await page.route(sceneUrl, (route) =>
+      route.fulfill({
+        contentType: 'application/vnd.peach.scene-stream+gzip',
+        body: Buffer.from(options.scene),
+      }),
+    )
+    url.searchParams.set(
+      'remoteEngine',
+      JSON.stringify({ url: sceneUrl, expectedPeer: header.peer, autoplay: false }),
+    )
+    await page.goto(url.href)
+    await page
+      .locator('[data-sootsim-boot-splash="hidden"]')
+      .waitFor({ state: 'attached', timeout: 120_000 })
+    await page.waitForFunction(
+      () => !!window.SootSim?.bridges.recorder && !!window.SootSim.bridges.sceneStream,
+      undefined,
+      { timeout: 120_000 },
+    )
+    const result = await page.evaluate(async () => {
+      const recorder = window.SootSim?.bridges.recorder
+      if (!recorder) throw new Error('scene recorder bridge unavailable')
+      return recorder.renderScene()
+    })
+    const chunks: Buffer[] = []
+    let offset = 0
+    for (;;) {
+      const chunk = await page.evaluate(async (at) => {
+        return window.SootSim?.bridges.recorder?.getBlobBase64({ offset: at })
+      }, offset)
+      if (!chunk) throw new Error('scene render returned no video')
+      chunks.push(Buffer.from(chunk.data, 'base64'))
+      offset = chunk.offset
+      if (chunk.done) break
+    }
+    const video = Buffer.concat(chunks)
+    await writeFile(options.output, video)
+    return { ...result, sizeBytes: video.byteLength }
+  } finally {
+    await browser.close()
+  }
+}

package/cli/ws-bridge.ts

@@ -10,6 +10,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { WebSocket } from 'ws'
 import {
+  assertPeachPortEnvironment,
   DEFAULT_SOOTSIM_BRIDGE_PORT,
   resolveSootsimBridgePort,
 } from '../src/bridge-constants'
@@ -31,6 +32,7 @@ import {
   readCurrentSimId,
   saveCurrentSimId,
 } from './current-sim'
+import { setPauseAwareTimeout } from './pause-aware-timeout'
 import type { WsBridgeCommand } from '../src/bridge-contract'
 
 // --- bridge world resolution ---------------------------------------------
@@ -297,6 +299,7 @@ export function resolveBridgePortForPin(pin: {
  *  vs repo checkout) — invocation-path heuristics made `peach list` flap
  *  between worlds. */
 export function resolveDefaultBridgePort(): number {
+  assertPeachPortEnvironment(process.env)
   return resolveBridgeWorld().bridgePort
 }
 
@@ -574,6 +577,7 @@ export function parseBridgeCliArgs(
 }
 
 export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBridge {
+  assertPeachPortEnvironment(process.env)
   let nextId = 1
   const commandTimeoutMs = opts.commandTimeoutMs ?? 15000
   const pending = new Map<
@@ -754,30 +758,35 @@ export function createBridge(wsPort: number, opts: WsBridgeOptions = {}): WsBrid
         if (terminalError) throw terminalError
         const id = nextId++
         return new Promise((resolve, reject) => {
-          const timeout = setTimeout(() => {
-            pending.delete(id)
-            reject(
-              new Error(
-                `command timed out after ${Math.round(effectiveTimeoutMs / 1000)}s`,
-              ),
-            )
-          }, effectiveTimeoutMs)
+          const payload = { ...(cmdOverride ?? cmd), id } as Record<string, any>
+          if (payload.simId === undefined && defaultSimId) {
+            payload.simId = defaultSimId
+          }
+
+          const clearTimeoutFn = setPauseAwareTimeout(
+            () => {
+              pending.delete(id)
+              reject(
+                new Error(
+                  `command timed out after ${Math.round(effectiveTimeoutMs / 1000)}s`,
+                ),
+              )
+            },
+            effectiveTimeoutMs,
+            lineageBySimId.get(payload.simId)?.hostPid,
+          )
 
           pending.set(id, {
             resolve: (v) => {
-              clearTimeout(timeout)
+              clearTimeoutFn()
               resolve(v)
             },
             reject: (e) => {
-              clearTimeout(timeout)
+              clearTimeoutFn()
               reject(e)
             },
           })
 
-          const payload = { ...(cmdOverride ?? cmd), id } as Record<string, any>
-          if (payload.simId === undefined && defaultSimId) {
-            payload.simId = defaultSimId
-          }
           maybeNoticeTarget(payload.type ?? '', payload.simId)
           ws.send(JSON.stringify(payload))
         })

package/detox/attempt-events.cjs

@@ -125,6 +125,10 @@ function beginDiscreteFrameCapture({
 }) {
   if (target.startsWith('android'))
     throw new Error('discrete frame cadence is uncalibrated on Android')
+  if (!fs.existsSync(path.join(root, 'capture-context.json')))
+    throw new Error(
+      `discrete frame cadence needs an attempt minted by the paired proof capture (bun run test:conformance:proof); ${root} has no capture-context.json`,
+    )
   const attempt = JSON.parse(
     fs.readFileSync(path.join(root, 'capture-context.json'), 'utf8'),
   )