peachsim 0.1.1635 → 0.1.1641

package/detox/attempt-events.cjs

@@ -43,6 +43,15 @@ function proofBoundPath(root, relative) {
   return resolved
 }
 
+// lifecycle receipts bind every clock and census read to the retained bytes.
+function boundText(root, relative, sha256, label) {
+  const bytes = fs.readFileSync(proofBoundPath(root, relative))
+  if (proofByteHash(bytes) !== sha256)
+    throw new Error(`${label} does not match its recorded hash`)
+  return bytes.toString('utf8')
+}
+module.exports.boundText = boundText
+
 function authenticateDiscreteFrameAsset(root, declaration, calibrate = false) {
   const cadence = parseDiscreteFrameCadence(declaration)
   const fixture = fs.readFileSync(proofBoundPath(root, cadence.asset.fixturePath))
@@ -309,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 ||
@@ -322,28 +335,71 @@ function authenticateNativeCadenceCensus(root, sourceRoot, life, decoded) {
       )
   )
     throw new Error('native cadence has no source-matched framebuffer consumer')
-  const frames = fs
-    .readFileSync(proofBoundPath(root, native.receipt), 'utf8')
+  const frames = boundText(
+    root,
+    native.receipt,
+    native.receiptSha256,
+    'native cadence source receipt',
+  )
     .trim()
     .split('\n')
     .map(JSON.parse)
-  const media = fs
-    .readFileSync(proofBoundPath(root, native.mediaFrames), 'utf8')
+  const media = boundText(
+    root,
+    native.mediaFrames,
+    native.mediaFramesSha256,
+    '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,
   } = require('../../peach-conformance/e2e/utils/native-frame-receipt.cjs')
   const rawRoot = path.dirname(proofBoundPath(root, native.receipt))
+  // a callback whose frame a newer one overwrote mid-read keeps no bytes; its
+  // superseded receipt fills exactly the gap it leaves in the callback order
+  const superseded = new Set(
+    boundText(
+      root,
+      native.superseded,
+      native.supersededSha256,
+      'native cadence superseded receipt',
+    )
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        const row = JSON.parse(line)
+        if (
+          !Number.isSafeInteger(row.callbackIndex) ||
+          row.seedBeforeRead === row.seedAfterRead
+        )
+          throw new Error('native superseded receipt is not an overwritten read')
+        return row.callbackIndex
+      }),
+  )
+  const reads = boundText(
+    root,
+    native.reads,
+    native.readsSha256,
+    'native cadence observations',
+  )
+    .split('\n')
+    .filter(Boolean)
+    .map(JSON.parse)
+  let expectedCallback = 0
+  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 !== index ||
       media[index].sourceFrameIndex !== index ||
       !clock ||
       clock.domain !== 'host-mach-absolute-time' ||
@@ -374,6 +430,9 @@ function authenticateNativeCadenceCensus(root, sourceRoot, life, decoded) {
       ),
     )
   }
+  while (superseded.delete(expectedCallback)) expectedCallback++
+  if (superseded.size)
+    throw new Error('native superseded receipts fall outside the callback order')
 }
 
 function readDiscreteFrameReceipt(root, sourceRoot, reference, expected) {
@@ -710,10 +769,44 @@ function discreteFrameEvidenceFiles(root, evidence) {
       const life = JSON.parse(
         fs.readFileSync(proofBoundPath(root, receipt.lifecycle.path), 'utf8'),
       )
+      // the app's ui frame clock and delivered input are replayed from their
+      // own receipts, so their bytes travel bound to the hashes the lifecycle
+      // recorded
+      for (const [label, auxiliary] of [
+        ['ui frame clock', life.uiFrameClock],
+        ['delivered input', life.deliveredUIKitInput],
+      ]) {
+        if (!auxiliary) continue
+        const bytes = fs.readFileSync(proofBoundPath(root, auxiliary.sourceReceipt))
+        if (proofByteHash(bytes) !== auxiliary.sourceReceiptSha256)
+          throw new Error(`native ${label} receipt does not match its recorded hash`)
+        paths.add(auxiliary.sourceReceipt)
+      }
       const native = life.nativeFramebuffer
       if (native) {
         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/attempt-events.d.cts

@@ -104,3 +104,10 @@ export function writeDiscreteFrameReceipt(
   context: DiscreteProofContext,
   trace: DiscreteFrameTrace,
 ): DiscreteProofReference
+
+export function boundText(
+  root: string,
+  relative: string,
+  sha256: string,
+  label: string,
+): string

package/detox/expectations.ts

@@ -54,8 +54,12 @@ export function isNodeVisible(node: SootSimNodeInfo | null | undefined): boolean
 }
 
 // a native host is focused when its editor child holds focus.
-export function focusIsWithin(focused: SootSimFocusedNodeInfo, nodeId: number): boolean {
-  return focused.nodeId === nodeId || focused.ancestorNodeIds.includes(nodeId)
+export function focusIsWithin(
+  focused: SootSimFocusedNodeInfo,
+  node: SootSimNodeInfo,
+): boolean {
+  const nativeNodeId = node.nativeTag ?? node.nodeId
+  return focused.nodeId === nativeNodeId || focused.ancestorNodeIds.includes(nativeNodeId)
 }
 
 // the engine owns focus for canvas inputs and hosted native editors.
@@ -64,7 +68,7 @@ export async function isTextInputNodeFocused(
   page: Page,
 ): Promise<boolean> {
   const focused = await page.evaluate(async () => window.__sootsimTest!.getFocusedNode())
-  return focused !== null && focusIsWithin(focused, node.nodeId)
+  return focused !== null && focusIsWithin(focused, node)
 }
 
 async function isNodeFocused(node: SootSimNodeInfo, page: Page): Promise<boolean> {