peachsim 0.1.1640 → 0.1.1641

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/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/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()

package/detox/index.ts

@@ -14,7 +14,11 @@ import {
   type ChromiumLaunchAdmission,
 } from '../../../scripts/lib/reap-browser'
 import { automateWebAuthenticationSessions } from '../../peach-engine/src/web-authentication-automation-host'
-import type { LockstepInputReceipt, SootSimLockstepFrameReceipt } from '@peach/globals'
+import type {
+  LockstepInputReceipt,
+  LockstepScheduledInput,
+  SootSimLockstepFrameReceipt,
+} from '@peach/globals'
 export { reserveChromiumAdmission } from '../../../scripts/lib/reap-browser'
 import {
   readBrowserCompositeCaptureRequest,
@@ -72,6 +76,8 @@ import type { DiscreteProofContext } from './attempt-events.cjs'
 import type { SootSimElement } from './element-types'
 import type { Browser, BrowserContext, Page } from 'playwright-core'
 
+const WORKLET_FRAME_TRACE_LIMIT = 16384
+
 type DiscreteStageFrame = {
   label: string
   offsetMs: number
@@ -492,8 +498,12 @@ async function waitForSootsimWorkletsIdle(page: Page, timeout = 3000): Promise<v
   )
   if (!result?.settled) {
     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)})`,
+    throw await describeSootsimBridgeFailure(
+      page,
+      new Error(
+        `sootsim worklet runtime did not settle after ${result?.elapsed ?? timeout}ms (pending=${pending}; observation=${JSON.stringify(result?.observation)})`,
+      ),
+      'sootsim worklet runtime did not settle',
     )
   }
 }
@@ -2119,7 +2129,7 @@ export const device = {
   },
 
   async uninstallApp() {
-    // no-op
+    await closeBrowser(false)
   },
 
   async openURL(url: { url: string; sourceApp?: string }) {
@@ -2639,15 +2649,18 @@ export const device = {
     options: {
       detectionTimeoutMs?: number
       workletFrameTimestampsSeconds?: number[]
+      workletFrameTracePath?: string
       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. 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.
+      // since the press. an explicit release position preserves witnessed up coordinates.
       hold?: {
         durationMs: number
-        moves?: Array<{ afterMs: number; x: number; y: number }>
+        eventDurationMs?: number
+        release?: { x: number; y: number }
+        moves?: Array<{ afterMs: number; eventAfterMs?: number; x: number; y: number }>
         x: number
         y: number
       } | null
@@ -2703,6 +2716,14 @@ export const device = {
       definition: MOTION_CHANGE_DEFINITION,
       installGlobal: true,
     })
+    if (options.workletFrameTracePath) {
+      await page.evaluate(async (limit) => {
+        const enable = window.SootSim?.bridges?.test?.setShellReanimatedTraceEnabled
+        if (typeof enable !== 'function')
+          throw new Error('worklet trace bridge is absent')
+        await enable(true, true, limit)
+      }, WORKLET_FRAME_TRACE_LIMIT)
+    }
     const capturePromise: Promise<{
       inputReceipts: LockstepInputReceipt[]
       anchors: Array<{
@@ -2877,61 +2898,9 @@ export const device = {
         const controller = await lockstep.begin(60, {
           workletFrameTimestampsSeconds: input.workletFrameTimestampsSeconds,
         })
-        // the hold's pointer goes down before the first stepped frame, so its
-        // start is one frame before the first receipt; each move and the release
-        // land on the first stepped frame at or past their time from there. the
-        // deadlines are frame indexes: comparing summed virtual timestamps
-        // against a duration lets rounding push an event past its frame.
-        const moves = input.hold?.moves ?? []
-        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,
-        }
-        const holdEventFrameIndex = (afterMs: number) =>
-          (holdState.pressFrameIndex ?? 0) + controller.framesForOffset(afterMs)
-        const nextHoldEventFrameIndex = () => {
-          if (!input.hold || holdState.released || holdState.pressFrameIndex === null) {
-            return null
-          }
-          const move = moves[holdState.nextMove]
-          return holdEventFrameIndex(move ? move.afterMs : input.hold.durationMs)
-        }
-        const advanceHold = async (receipt: SootSimLockstepFrameReceipt) => {
-          if (!input.hold || !interact || holdState.released) return
-          if (holdState.pressFrameIndex === null) {
-            holdState.pressFrameIndex = receipt.frameIndex - 1
-          }
-          for (
-            let move = moves[holdState.nextMove];
-            move && receipt.frameIndex >= holdEventFrameIndex(move.afterMs);
-            move = moves[holdState.nextMove]
-          ) {
-            holdState.nextMove++
-            holdState.x = move.x
-            holdState.y = move.y
-            // event time remains on the replay clock when delivery ceilings
-            // to a display tick or several native samples share one frame.
-            await interact.touchMove(
-              move.x,
-              move.y,
-              999,
-              controller.initialFrame.virtualTimestampMs + move.afterMs,
-            )
-          }
-          if (receipt.frameIndex < holdEventFrameIndex(input.hold.durationMs)) return
-          holdState.released = true
-          holdState.releaseReceipt = receipt
-          await interact.touchUp(
-            holdState.x,
-            holdState.y,
-            999,
-            controller.initialFrame.virtualTimestampMs + input.hold.durationMs,
-          )
-        }
+        let heldInput: Promise<void> | null = null
+        const releaseReceipt = () =>
+          controller.inputReceipts.find((receipt) => receipt.phase === 'up')
         // an anchor is its visible-change frame; its bitmap is kept so a 0ms
         // stage can still capture the anchor frame itself.
         const keptFrames = new Map<
@@ -2960,17 +2929,51 @@ export const device = {
             throw new Error('paired worklets callback preceded the Peach trigger')
           state.ready = true
           if (input.hold && interact) {
-            const hit = await interact.touchDown(
-              input.hold.x,
-              input.hold.y,
-              999,
-              controller.initialFrame.virtualTimestampMs,
-            )
-            if (!hit) {
-              throw new Error(
-                `peach motion hold missed at ${input.hold.x},${input.hold.y}`,
-              )
-            }
+            const hold = input.hold
+            const moves = hold.moves ?? []
+            const release = hold.release ?? moves.at(-1) ?? hold
+            const events: LockstepScheduledInput[] = [
+              {
+                phase: 'down',
+                x: hold.x,
+                y: hold.y,
+                pointerId: 999,
+                afterMs: 0,
+                async deliver(timestamp) {
+                  const hit = await interact.touchDown(hold.x, hold.y, 999, timestamp)
+                  if (!hit)
+                    throw new Error(`peach motion hold missed at ${hold.x},${hold.y}`)
+                },
+              },
+              ...moves.map(
+                (move): LockstepScheduledInput => ({
+                  phase: 'move',
+                  x: move.x,
+                  y: move.y,
+                  pointerId: 999,
+                  afterMs: move.afterMs,
+                  eventAfterMs: move.eventAfterMs,
+                  async deliver(timestamp: number) {
+                    await interact.touchMove(move.x, move.y, 999, timestamp)
+                  },
+                }),
+              ),
+              {
+                phase: 'up',
+                x: release.x,
+                y: release.y,
+                pointerId: 999,
+                afterMs: hold.durationMs,
+                eventAfterMs: hold.eventDurationMs,
+                async deliver(timestamp) {
+                  await interact.touchUp(release.x, release.y, 999, timestamp)
+                },
+              },
+            ]
+            heldInput = controller.scheduleInput(events)
+            // rendering propagates delivery errors; also observe cancellation rejection.
+            heldInput.catch(() => {})
+            await controller.flushFrame()
           } else {
             while (!state.triggerStarted) {
               if (state.cancelled) throw new Error('peach motion capture was cancelled')
@@ -3008,12 +3011,12 @@ export const device = {
           for (let frame = 0; !visibleStart && frame < detectionFrameLimit; frame++) {
             if (state.cancelled) throw new Error('peach motion capture was cancelled')
             const receipt = await controller.stepFrame()
-            await advanceHold(receipt)
             const candidateBitmap = await captureBitmap()
             // a touch anchor's stages may precede the first visible change
             if (
               input.anchorAtTouch === 'down' ||
-              (input.anchorAtTouch === 'up' && holdState.releaseReceipt === receipt)
+              (input.anchorAtTouch === 'up' &&
+                releaseReceipt()?.frameIndex === receipt.frameIndex)
             ) {
               keepFrame(receipt, await createImageBitmap(candidateBitmap))
             }
@@ -3053,17 +3056,17 @@ export const device = {
           let currentReceipt = visibleStart
           if (input.anchorAtTouch === 'down') driveStart = controller.initialFrame
           if (input.anchorAtTouch === 'up') {
-            while (!holdState.released) {
+            while (!releaseReceipt()) {
               if (state.cancelled) throw new Error('peach motion capture was cancelled')
               const receipt = await controller.stepFrame()
-              await advanceHold(receipt)
               currentReceipt = receipt
-              if (holdState.released) keepFrame(receipt, await captureBitmap())
+              if (releaseReceipt()) keepFrame(receipt, await captureBitmap())
             }
-            if (!holdState.releaseReceipt) {
+            const released = releaseReceipt()
+            if (!released) {
               throw new Error('peach release anchoring found no release frame')
             }
-            driveStart = holdState.releaseReceipt
+            driveStart = { ...released, tenantFrame: null }
           }
           const resolvedAnchors = new Map<string, SootSimLockstepFrameReceipt>()
           const anchorRecords: Array<{
@@ -3107,7 +3110,6 @@ export const device = {
             while (searchReceipt.virtualTimestampMs < searchStartVts) {
               if (state.cancelled) throw new Error('peach motion capture was cancelled')
               searchReceipt = await controller.stepFrame()
-              await advanceHold(searchReceipt)
             }
             currentReceipt = searchReceipt
             let anchorBitmap = await captureBitmap()
@@ -3123,7 +3125,6 @@ export const device = {
             for (let frame = 0; frame < detectionFrameLimit; frame++) {
               if (state.cancelled) throw new Error('peach motion capture was cancelled')
               const receipt = await controller.stepFrame()
-              await advanceHold(receipt)
               const candidateBitmap = await captureBitmap()
               const bounds = boundsFor(candidateBitmap)
               const candidate = regionPixels(candidateBitmap)
@@ -3176,9 +3177,6 @@ export const device = {
           for (const stage of input.stages) {
             if (state.cancelled) throw new Error('peach motion capture was cancelled')
             const { anchorId, receipt: anchorReceipt } = await resolveAnchor(stage)
-            // step through every hold move and the release that fall before
-            // this stage one frame at a time, so the stage paints the pointer
-            // where it belongs rather than a hold the jump skipped past.
             const stageFrameIndex =
               anchorReceipt.frameIndex + controller.framesForOffset(stage.offsetMs)
             const kept = keptFrames.get(stageFrameIndex)
@@ -3195,15 +3193,7 @@ export const device = {
               })
               continue
             }
-            for (
-              let eventFrameIndex = nextHoldEventFrameIndex();
-              eventFrameIndex !== null && stageFrameIndex > eventFrameIndex;
-              eventFrameIndex = nextHoldEventFrameIndex()
-            ) {
-              await advanceHold(await controller.stepFrame())
-            }
             const receipt = await controller.stepToOffset(anchorReceipt, stage.offsetMs)
-            await advanceHold(receipt)
             currentReceipt = receipt
             snapshots.push({
               actualMs: receipt.virtualTimestampMs - anchorReceipt.virtualTimestampMs,
@@ -3222,11 +3212,11 @@ export const device = {
           // own frames; the settle jump below would carry the pointer past them
           // and leave it down. the settle then runs from that release.
           let releasedOffsetMs = 0
-          while (nextHoldEventFrameIndex() !== null) {
+          while (input.hold && !releaseReceipt()) {
             const receipt = await controller.stepFrame()
-            await advanceHold(receipt)
             releasedOffsetMs = receipt.virtualTimestampMs - driveStart.virtualTimestampMs
           }
+          await heldInput
           if (input.settleMs > 0) {
             const maximumPrimaryMs = snapshots.reduce(
               (maximum, snapshot) =>
@@ -3297,23 +3287,25 @@ export const device = {
       },
     )
 
-    await Promise.race([
-      page.waitForFunction(
-        (captureToken) => {
-          const registry = window.__sootsimVisibleChangeCaptures
-          return registry?.[captureToken]?.ready === true
-        },
-        token,
-        { timeout: 5000 },
-      ),
-      capturePromise.then(() => {
-        throw new Error('peach motion capture completed before its trigger')
-      }),
-    ])
-
-    const triggerStartMs = Date.now()
+    let captureFailure: { error: unknown } | undefined
+    let triggerStartMs = 0
     let triggerCompletedMs = 0
     try {
+      await Promise.race([
+        page.waitForFunction(
+          (captureToken) => {
+            const registry = window.__sootsimVisibleChangeCaptures
+            return registry?.[captureToken]?.ready === true
+          },
+          token,
+          { timeout: 5000 },
+        ),
+        capturePromise.then(() => {
+          throw new Error('peach motion capture completed before its trigger')
+        }),
+      ])
+
+      triggerStartMs = Date.now()
       const triggerPromise = (async () => {
         if (!options.hold) {
           if (typeof options.trigger !== 'function') {
@@ -3349,6 +3341,7 @@ export const device = {
         },
       }
     } catch (error) {
+      captureFailure = { error }
       await page
         .evaluate((captureToken) => {
           const registry = window.__sootsimVisibleChangeCaptures
@@ -3358,6 +3351,59 @@ export const device = {
         .catch(() => {})
       await capturePromise.catch(() => {})
       throw error
+    } finally {
+      if (options.workletFrameTracePath) {
+        try {
+          const events = await page.evaluate(async () => {
+            const test = window.SootSim?.bridges?.test
+            const read = test?.getShellReanimatedTrace
+            const enable = test?.setShellReanimatedTraceEnabled
+            if (typeof read !== 'function' || typeof enable !== 'function')
+              throw new Error('worklet trace bridge is absent')
+            try {
+              return await read()
+            } finally {
+              await enable(false, false)
+            }
+          })
+          fs.writeFileSync(
+            options.workletFrameTracePath,
+            JSON.stringify(
+              {
+                source: 'peach-native-frame-queue',
+                limit: WORKLET_FRAME_TRACE_LIMIT,
+                events,
+              },
+              null,
+              2,
+            ),
+          )
+        } catch (traceError) {
+          if (!captureFailure) throw traceError
+          const primary = captureFailure.error
+          if (
+            primary &&
+            (typeof primary === 'object' || typeof primary === 'function') &&
+            Object.isExtensible(primary)
+          ) {
+            try {
+              Object.defineProperty(primary, 'workletFrameTraceError', {
+                value: traceError,
+                configurable: true,
+              })
+            } catch (attachmentError) {
+              console.error(
+                '[peach motion capture] could not attach trace failure:',
+                attachmentError,
+              )
+            }
+          }
+          console.error(
+            '[peach motion capture] secondary worklet trace failure:',
+            traceError,
+          )
+        }
+      }
     }
   },
 

package/detox/jest-environment.cjs

@@ -50,11 +50,15 @@ module.exports = class PeachEnvironment extends TestEnvironment {
     }
   }
 
-  async handleTestEvent(event) {
+  async handleTestEvent(event, state) {
     if (event.name === 'hook_failure') {
       this.controller.abort(new Error('Peach test hook failed'))
       try {
         await this.global.__peachDetoxCleanup?.()
+      } catch (error) {
+        // circus already recorded the hook failure. a cleanup failure belongs
+        // beside it, rather than escaping this handler and replacing the result.
+        state.unhandledErrors.push(error)
       } finally {
         this.releaseAdmission?.()
         this.releaseAdmission = null

package/dist-lib/agent-daemon-client.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1640 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1641 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/agent-events.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1640 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1641 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/attached-projects.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1640 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1641 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/auth/shared-session.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1640 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1641 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;