peachsim 0.1.1640 → 0.1.1644

package/cli/commands/record.ts

@@ -168,6 +168,7 @@ const RECORD_VALUE_FLAGS = new Set([
   '--repo',
   '--scene',
   '--shell-url',
+  '--timeout',
 ])
 const RECORD_SUBCOMMANDS = new Set([
   'start',
@@ -924,8 +925,6 @@ async function recordStart(args: string[], opts: RecordOptions) {
         peachExit(1)
       }
     } else {
-      await assertRecorderAvailable(bridge)
-      await assertTabVisibleForCapture(bridge)
       const lockstep = args.includes('--lockstep')
       if (lockstep && format !== 'mp4') {
         console.error('  --lockstep requires --format mp4 (webm is realtime-clocked)')
@@ -942,7 +941,11 @@ async function recordStart(args: string[], opts: RecordOptions) {
       writeRecordingState(session)
       const result: { ok: boolean; error?: string } = await bridge.send({
         type: 'evaluate',
-        code: `window.__sootsimRecorder.start(${JSON.stringify(startOpts)})`,
+        code: `(() => {
+          if (!window.__sootsimRecorder) return { ok: false, error: 'recorder unavailable in this sim' };
+          if (document.hidden) return { ok: false, error: 'the peach tab is hidden; bring it to the foreground before recording' };
+          return window.__sootsimRecorder.start(${JSON.stringify(startOpts)});
+        })()`,
       })
       if (!result.ok) {
         clearRecordingState()
@@ -1022,7 +1025,13 @@ async function recordPreludeStart(args: string[], opts: RecordOptions) {
 //   - the event recorder alone drives hidden PR-preview preludes before a
 //     visible live/combined segment exists
 // returns null when the engine can't be reached.
-type EngineRecordingState = 'idle' | 'recording' | 'processing' | 'prelude'
+type EngineRecordingState =
+  | 'idle'
+  | 'starting'
+  | 'recording'
+  | 'processing'
+  | 'ready'
+  | 'prelude'
 
 async function probeEngineRecordingState(
   bridge: WsBridge,
@@ -1043,8 +1052,10 @@ async function probeEngineRecordingState(
       })()`,
       })
     if (!snap) return null
+    if (snap.headless === 'starting') return 'starting'
     if (snap.store === 'recording' || snap.headless === 'recording') return 'recording'
-    if (snap.store === 'processing') return 'processing'
+    if (snap.store === 'processing' || snap.headless === 'processing') return 'processing'
+    if (snap.headless === 'ready') return 'ready'
     if (snap.eventRecording) return 'prelude'
     if (snap.store === 'idle' || snap.headless === 'idle') return 'idle'
     return null
@@ -1089,26 +1100,36 @@ async function cancelEngineRecording(bridge: WsBridge): Promise<{
 
 async function recordStatus(args: string[], opts: RecordOptions) {
   const state = readRecordingState()
-  if (state) {
-    noteSimMismatch(parseBridgeCliArgs(args, { port: opts.port }).simId, state)
-    if (state.mode === 'video') {
-      console.log(
-        `  recording ${state.mode} (${state.format} @ ${state.fps}fps) on sim ${state.simId ?? '?'} since ${state.startedAt}`,
-      )
-    } else {
-      console.log(
-        `  recording ${state.mode} on sim ${state.simId ?? '?'} since ${state.startedAt}`,
-      )
-    }
-    return
-  }
-  // no `record start` session — but an atomic run or the rail button may
-  // still be recording. ask the engine before claiming nothing is happening.
-  const parsed = parseBridgeCliArgs(args, { port: opts.port, commandTimeoutMs: 8_000 })
-  const bridge = createBridgeFromParsed(parsed)
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    commandTimeoutMs: 8_000,
+  })
+  if (state) noteSimMismatch(parsed.simId, state)
+  const bridge = createBridgeFromParsed({
+    ...parsed,
+    simId: state?.simId ?? parsed.simId,
+  })
   try {
     const engineState = await probeEngineRecordingState(bridge)
+    if (state) {
+      if (engineState === 'idle') {
+        clearRecordingState()
+        console.log('  no recording in progress')
+      } else if (engineState === 'ready') {
+        console.log('  recording ready to save — run `peach record stop --output <path>`')
+      } else if (engineState === null) {
+        console.log(
+          '  recording state unavailable — the sim did not respond; the tracked session is preserved',
+        )
+      } else {
+        console.log(
+          `  ${engineState} ${state.mode}${state.mode === 'video' ? ` (${state.format} @ ${state.fps}fps)` : ''} on sim ${state.simId ?? '?'} since ${state.startedAt}`,
+        )
+      }
+      return
+    }
     if (
+      engineState === 'starting' ||
       engineState === 'recording' ||
       engineState === 'processing' ||
       engineState === 'prelude'
@@ -1154,8 +1175,10 @@ async function recordCancel(args: string[], opts: RecordOptions) {
     try {
       const engineState = await probeEngineRecordingState(probeBridge)
       if (
+        engineState === 'starting' ||
         engineState === 'recording' ||
         engineState === 'processing' ||
+        engineState === 'ready' ||
         engineState === 'prelude'
       ) {
         // `record cancel` is explicit intent: the caller wants whatever is
@@ -1204,7 +1227,11 @@ async function recordCancel(args: string[], opts: RecordOptions) {
     } else {
       await bridge.send({
         type: 'evaluate',
-        code: `window.__sootsimRecorder.stop()`,
+        code: `(async () => {
+          const recorder = window.__sootsimRecorder;
+          await recorder.stop();
+          return recorder.forceRelease();
+        })()`,
       })
     }
   } catch {
@@ -1241,7 +1268,15 @@ async function recordStop(args: string[], opts: RecordOptions) {
   const bridge = createBridgeFromParsed({ ...parsed, simId })
   try {
     if (state.mode === 'live' || state.mode === 'combined') {
-      if (!(await evalStoreStop(bridge))) {
+      const stopped = await evalStoreStop(bridge)
+      if (stopped === 'pending') {
+        console.error(
+          `  stop failed: the ${state.mode} start is still in flight and has not begun a take yet.\n` +
+            '  run `peach record stop` again once it begins.',
+        )
+        peachExit(1)
+      }
+      if (!stopped) {
         clearRecordingState()
         console.error(
           `  stop failed: the ${state.mode} start still in flight never began a take, so there is nothing to upload.\n` +
@@ -1444,13 +1479,14 @@ async function evalStoreStart(
 
 // the engine stop waits for a start still in flight. false means that start
 // never began a take, so no upload will come and the store's last one belongs
-// to an earlier take.
-async function evalStoreStop(bridge: WsBridge): Promise<boolean> {
-  const stopped: boolean | null = await bridge.send({
+// to an earlier take. 'pending' means the start was still pending when the
+// engine stopped waiting, so it may yet begin one.
+async function evalStoreStop(bridge: WsBridge): Promise<boolean | 'pending'> {
+  const stopped: boolean | 'pending' | null = await bridge.send({
     type: 'evaluate',
     code: `window.SootSim.bridges.stopRecording()`,
   })
-  return stopped !== false
+  return stopped === 'pending' ? stopped : stopped !== false
 }
 
 interface StoreUploadResult {

package/cli/commands/swift.ts

@@ -165,7 +165,15 @@ export async function runSwift(
   const appProject = resolveAppProject(packagePath)
   host.configureSwiftStandinBehavior(packagePath, await loadRNXAppConfig(appProject))
   // collection preflights every input path before any source bytes are read.
-  host.swiftPackageWatchFiles(packagePath, undefined)
+  try {
+    host.swiftPackageWatchFiles(packagePath, undefined)
+  } catch (error) {
+    const { SwiftObjCCompilationError } = await import('../../src/swift-objc-compile')
+    if (!(error instanceof SwiftObjCCompilationError)) throw error
+    console.error(error.message)
+    host.disposeSwiftProject(packagePath)
+    return 1
+  }
   const packageName = path.basename(packagePath)
   const appInfo = host.swiftProjectAppInfo(packagePath)
   const guestSource = swiftGuestBundle(packageName)
@@ -354,7 +362,7 @@ export async function runSwift(
     await refresh()
     controller.signal.throwIfAborted()
     // refresh already printed the error
-    if (!metadata || compileError) throw new Error('Swift compilation failed, see above')
+    if (!metadata || compileError) return 1
     if (opts.device) openArgs.push('--device', opts.device)
     if (opts.driver) openArgs.push('--driver', opts.driver)
     if (opts.headless) openArgs.push('--headless')

package/cli/commands/three-mode.ts

@@ -6,6 +6,10 @@
 import { createHash } from 'node:crypto'
 import { mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs'
 import { dirname, extname, resolve } from 'node:path'
+import {
+  collectTimelineAssetRefs,
+  timelineAssetRefOf,
+} from 'peach-engine/screenshots/timeline-assets'
 import {
   isThreeModeSetting,
   THREE_MODE_SETTING_IDS,
@@ -353,44 +357,6 @@ function mimeTypeForAsset(path: string, contentType: unknown) {
 // timeline as blob: URLs.
 const TIMELINE_ASSET_CHUNK_BYTES = 1_048_576
 
-type TimelineAssetRef = {
-  src: string
-  recording: boolean
-}
-
-function timelineAssetRefOf(value: Record<string, unknown>): TimelineAssetRef | null {
-  if (
-    (value.type === 'recording' ||
-      value.type === 'screenshot' ||
-      value.kind === 'screen') &&
-    typeof value.src === 'string' &&
-    !/^(?:blob:|data:|https?:)/i.test(value.src)
-  ) {
-    return { src: value.src, recording: value.type === 'recording' }
-  }
-  return null
-}
-
-function collectTimelineAssetRefs(value: unknown): TimelineAssetRef[] {
-  const refs: TimelineAssetRef[] = []
-  const seen = new Set<string>()
-  const visit = (node: unknown): void => {
-    if (Array.isArray(node)) {
-      for (const entry of node) visit(entry)
-      return
-    }
-    if (!isRecord(node)) return
-    for (const entry of Object.values(node)) visit(entry)
-    const ref = timelineAssetRefOf(node)
-    if (ref && !seen.has(ref.src)) {
-      seen.add(ref.src)
-      refs.push(ref)
-    }
-  }
-  visit(value)
-  return refs
-}
-
 type DistinctTimelineAsset = {
   hash: string
   mime: string

package/cli/commands/upload.ts

@@ -522,7 +522,7 @@ export async function runUpload(
       bridge,
       '(typeof window.__sootsimCaptureBundle === "function") ? window.__sootsimCaptureBundle() : null',
     )
-    if (snapshot?.bundleUrl) {
+    if (hasBundle && snapshot?.bundleUrl) {
       const bundleOrigin = new URL(snapshot.bundleUrl).origin
       // manifest stays the body-less re-fetch path for bundle-origin static
       // assets (chunks, fonts, wasm). bundle-origin api endpoints would also
@@ -784,7 +784,7 @@ export async function runUpload(
     .join('\n')
   const timelineGz = gzipSync(traceTimelineJsonl ? `${traceTimelineJsonl}\n` : '')
   const storageGz =
-    opts.storageSnapshot && hasShareableStorage(opts.storageSnapshot)
+    hasBundle && opts.storageSnapshot && hasShareableStorage(opts.storageSnapshot)
       ? gzipSync(JSON.stringify(opts.storageSnapshot))
       : undefined
   console.log(
@@ -971,10 +971,9 @@ export async function runUpload(
   // fetcher (same code path as the build's `peach app-fonts stage`) so both
   // pipelines store identical bytes keyed by sha256(url).
   const appFontFiles: PreparedFile[] = []
-  const appFontsWire = await resolveAppFontsWire(
-    appFontsWireFromPageHref(snapshot.pageHref),
-    fetch,
-  )
+  const appFontsWire = hasBundle
+    ? await resolveAppFontsWire(appFontsWireFromPageHref(snapshot.pageHref), fetch)
+    : ''
   if (appFontsWire) {
     const fonts = await fetchAppFontFiles(appFontsWire, {
       onStaged: ({ url, byteLength }) =>
@@ -1003,7 +1002,7 @@ export async function runUpload(
   // still-live metro and persist them keyed by sha256(url). the engine's
   // <img src> resolves them through the share fetch proxy in preview mode.
   const appSplashFiles: PreparedFile[] = []
-  const appSplashWire = appSplashWireFromPageHref(snapshot.pageHref) || ''
+  const appSplashWire = hasBundle ? appSplashWireFromPageHref(snapshot.pageHref) : ''
   if (appSplashWire) {
     const images = await fetchAppSplashImages(appSplashWire, {
       onStaged: ({ url, byteLength }) =>
@@ -1033,7 +1032,8 @@ export async function runUpload(
   // explicitly so the installed app keeps its identity in share replay.
   const appIdentityFiles: PreparedFile[] = []
   let appManifest: string | undefined
-  const metroOrigin = snapshot.bundleUrl ? loopbackOriginOf(snapshot.bundleUrl) : null
+  const metroOrigin =
+    hasBundle && snapshot.bundleUrl ? loopbackOriginOf(snapshot.bundleUrl) : null
   if (metroOrigin && snapshot.bundleUrl) {
     const platform = new URL(snapshot.bundleUrl).searchParams.get('platform') || 'ios'
     const manifestUrl = `${metroOrigin}/`

package/cli/drivers/playwright.ts

@@ -18,6 +18,7 @@ import { createServer } from 'net'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import { AUTOMATION_SIM_IDLE_REAP_TTL_MS } from '../../src/bridge-constants'
+import { getCliVersion } from '../../src/cli-version'
 import {
   desktopHostDelivery,
   desktopHostPlatform,
@@ -54,6 +55,38 @@ function probe(): DriverAvailability {
   }
 }
 
+// every bridge since the fetch transport landed serves its route, so a 404
+// from a server whose /healthz identifies a peach bridge means that bridge
+// predates this cli. without that identity the port may hold something else,
+// and the message says only what was observed. restarting closes every sim
+// the bridge hosts, so the cli never does it.
+async function olderBridgeMessage(bridgePort: number): Promise<string> {
+  const restart = `run \`peach daemon restart\` to load the matching bridge; it closes every sim that bridge hosts, so it was not restarted.`
+  let health: unknown = null
+  try {
+    const response = await fetch(`http://127.0.0.1:${bridgePort}/healthz`, {
+      signal: AbortSignal.timeout(10_000),
+    })
+    health = await response.json()
+  } catch {
+    // an unreadable /healthz leaves the server unidentified
+  }
+  const field = (key: string) =>
+    health && typeof health === 'object' ? Reflect.get(health, key) : null
+  const pid = field('pid')
+  if (field('ok') !== true || typeof pid !== 'number') {
+    return `port ${bridgePort} has no fetch transport route and its /healthz did not identify a peach bridge, so this peach cli ${getCliVersion()} cannot use it. if an older peach bridge holds that port, ${restart}`
+  }
+  const runtime = field('activeRuntime')
+  const details = [
+    `pid ${pid}`,
+    typeof runtime === 'string' ? `runtime ${runtime}` : null,
+  ]
+    .filter((part) => part !== null)
+    .join(', ')
+  return `the peach bridge on port ${bridgePort} (${details}) has no fetch transport route, so it predates this peach cli ${getCliVersion()}. ${restart}`
+}
+
 // resolve the Chrome user-data dir for a profiled launch. a non-empty
 // return means the host should use a persistent context; '' means a plain
 // (in-memory) browser launch.
@@ -111,6 +144,12 @@ async function launch(opts: DriverLaunchOptions): Promise<DriverLaunchResult> {
         `http://127.0.0.1:${opts.bridgePort}/__peach/fetch-transport`,
         { signal: AbortSignal.timeout(10_000) },
       )
+      if (response.status === 404) {
+        return {
+          launched: false,
+          message: await olderBridgeMessage(opts.bridgePort),
+        }
+      }
       if (!response.ok) throw new Error(`transport discovery returned ${response.status}`)
       const descriptor: unknown = await response.json()
       if (!descriptor || typeof descriptor !== 'object')

package/cli/flow-live-status.ts

@@ -13,8 +13,6 @@ export type LiveStepStatus = 'running' | 'success' | 'failure' | 'skipped'
 
 type PlanStep = { index: number; name: string; target?: string }
 
-const PAUSE_POLL_MS = 400
-
 function replyPaused(reply: unknown) {
   if (typeof reply !== 'object' || reply == null || !('control' in reply)) return false
   const control = reply.control

package/cli/main.ts

@@ -466,7 +466,7 @@ try {
         // inner verb's --json payload, so it never needs the shared bridge
         // machinery that lives inside runInspect.
         const { runAssert } = await import('./commands/assert')
-        await runAssert(parsed.commandArgs)
+        await runAssert(parsed.commandArgs, { port, sim: globalSimTarget })
         break
       }
 

package/cli/outbound-endpoints.ts

@@ -38,7 +38,7 @@ export const OUTBOUND_ENDPOINTS: Record<string, OutboundEndpointDeclaration> = {
   runtime_delivery: {
     category: 'runtime-delivery',
     destination:
-      'https://contrast.dev/runtimes/manifest.json and selected runtime tarball; with `peach desktop install --native`, https://r2.rnxsim.com/releases/native/<channel>/ manifest and versioned host zip',
+      'https://peachsim.com/runtimes/manifest.json and selected runtime tarball; with `peach desktop install --native`, https://r2.rnxsim.com/releases/native/<channel>/ manifest and versioned host zip',
     preConsent: true,
     payload: 'HTTP runtime or desktop host version request; no project or app data',
   },
@@ -107,7 +107,7 @@ export const OUTBOUND_ENDPOINTS: Record<string, OutboundEndpointDeclaration> = {
   },
   release_notes: {
     category: 'explicit-user-action',
-    destination: 'https://contrast.dev/api/changelog/sootsim',
+    destination: 'https://peachsim.com/api/changelog/sootsim',
     preConsent: false,
     payload: 'requested runtime version only',
   },
@@ -639,6 +639,8 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
     { category: 'local_development', count: 1 },
   'packages/peachsim/cli/drivers/playwright.ts :: fetch :: `http://127.0.0.1:${opts.bridgePort}/__peach/fetch-transport`':
     { category: 'local_development', count: 1 },
+  'packages/peachsim/cli/drivers/playwright.ts :: fetch :: `http://127.0.0.1:${bridgePort}/healthz`':
+    { category: 'local_development', count: 1 },
   "packages/peach-engine/src/screenshots/capture-store.ts :: fetch :: captureApiUrl(ref, 'grid')":
     { category: 'contrast_user_action', count: 1 },
   'packages/peach-engine/src/screenshots/capture-store.ts :: fetch :: captureApiUrl(ref, variant)':

package/cli/ws-bridge.ts

@@ -374,12 +374,6 @@ export class BridgeSimLockedError extends Error {
   }
 }
 
-interface WsResponse {
-  id: number
-  result?: any
-  error?: string
-}
-
 interface WsBridgeOptions {
   connectTimeoutMs?: number
   commandTimeoutMs?: number

package/detox/attempt-events.cjs

@@ -318,6 +318,10 @@ function writeDiscreteFrameReceipt(
 }
 
 function authenticateNativeCadenceCensus(root, sourceRoot, life, decoded) {
+  const {
+    authenticateNativeRefreshSamples,
+  } = require('../../peach-conformance/e2e/utils/native-frame-receipt.cjs')
+  authenticateNativeRefreshSamples(root, sourceRoot, life)
   const native = life.nativeFramebuffer
   if (
     !native ||
@@ -344,13 +348,13 @@ function authenticateNativeCadenceCensus(root, sourceRoot, life, decoded) {
     root,
     native.mediaFrames,
     native.mediaFramesSha256,
-    'native cadence presentation census',
+    'native cadence sampled surface census',
   )
     .trim()
     .split('\n')
     .map(JSON.parse)
   if (frames.length !== decoded.observations.length || media.length !== frames.length)
-    throw new Error('native cadence acquisition and presentation census differ')
+    throw new Error('native cadence acquisition and sampled surface census differ')
   const {
     decodeNativeFramebuffer,
     requireNativeRawFrame,
@@ -377,13 +381,25 @@ function authenticateNativeCadenceCensus(root, sourceRoot, life, decoded) {
         return row.callbackIndex
       }),
   )
-  const origin = frames[0].consumerArrival
+  const reads = boundText(
+    root,
+    native.reads,
+    native.readsSha256,
+    'native cadence observations',
+  )
+    .split('\n')
+    .filter(Boolean)
+    .map(JSON.parse)
   let expectedCallback = 0
-  for (const [index, frame] of frames.entries()) {
+  for (const read of reads) {
     while (superseded.delete(expectedCallback)) expectedCallback++
+    if (read.callbackIndex !== expectedCallback++)
+      throw new Error('native cadence observations have invalid callback order')
+  }
+  const origin = frames[0].consumerArrival
+  for (const [index, frame] of frames.entries()) {
     const clock = frame.consumerArrival
     if (
-      frame.callbackIndex !== expectedCallback++ ||
       media[index].sourceFrameIndex !== index ||
       !clock ||
       clock.domain !== 'host-mach-absolute-time' ||
@@ -771,6 +787,26 @@ function discreteFrameEvidenceFiles(root, evidence) {
         paths.add(native.receipt)
         paths.add(native.superseded)
         paths.add(native.mediaFrames)
+        paths.add(native.gradingMarkers)
+        paths.add(native.gradingPlan)
+        paths.add(native.windowResolution)
+        paths.add(native.reads)
+        for (const receipt of native.finalReads) {
+          const text = boundText(
+            root,
+            receipt.path,
+            receipt.sha256,
+            'native sampled end state',
+          )
+          paths.add(receipt.path)
+          for (const row of text.split('\n').filter(Boolean).map(JSON.parse)) {
+            const file = proofBoundPath(
+              path.dirname(proofBoundPath(root, receipt.path)),
+              row.rawPath,
+            )
+            paths.add(path.relative(root, file).split(path.sep).join('/'))
+          }
+        }
         const rows = fs
           .readFileSync(proofBoundPath(root, native.receipt), 'utf8')
           .trim()