peachsim 0.1.1406 → 0.1.1465

package/cli/commands/inspect/settling.ts

@@ -44,6 +44,23 @@ export class RuntimeReadinessUnsupportedError extends Error {
   }
 }
 
+// a thrown idle read carries the host elapsed time and the original failure.
+// it stays an error so callers cannot treat it as motion observed for maxMs.
+export class IdleObservationError extends Error {
+  readonly code = 'idle_observation_failed'
+
+  constructor(
+    readonly elapsedMs: number,
+    readonly failure: unknown,
+  ) {
+    const detail = failure instanceof Error ? failure.message : String(failure)
+    super(`idle observation failed after ${elapsedMs}ms: ${detail}`, {
+      cause: failure,
+    })
+    this.name = 'IdleObservationError'
+  }
+}
+
 export async function waitForSootsimIdle({
   bridge,
   simId,
@@ -54,6 +71,9 @@ export async function waitForSootsimIdle({
   paintStill = false,
 }: WaitForSootsimIdleOptions): Promise<WaitForSootsimIdleResult> {
   let result: any
+  // guest elapsed covers a completed read. this clock is read only when the
+  // bridge throws, so a successful settle does not report host time.
+  const observationStartedAt = Date.now()
   try {
     result = await bridge.send(
       {
@@ -84,27 +104,23 @@ export async function waitForSootsimIdle({
       let screenPixels = null
       try {
 
-        // route-aware settle: a tap that pushes/pops a screen is async — the
-        // old screen still renders for a moment, then the new one mounts and
-        // its content loads. a pure layout-hash check reports "idle" on the
-        // outgoing screen or on the incoming skeleton, so a driver re-taps
-        // and stacks duplicate navigations. drain any in-flight screen
-        // transition FIRST, bounded by the overall budget. when no
-        // transition is happening this returns in ~80ms (startWindowMs), so
-        // a plain button tap barely pays for it.
-        try {
-          const wfst = window.__sootsimTest?.waitForScreenTransitions
-          if (typeof wfst === 'function') {
+        // discover transitions while observing layout. when motion starts,
+        // observations from before its completion cannot prove the new screen.
+        let transitionWait = (async () => {
+          try {
+            const wfst = window.__sootsimTest?.waitForScreenTransitions
             const remaining = deadline - Date.now()
-            if (remaining > 120) {
-              await wfst({
+            if (typeof wfst === 'function' && remaining > 120) {
+              const transition = await wfst({
                 timeoutMs: Math.min(remaining - 80, 4000),
                 settleMs: 64,
                 startWindowMs: 80,
               })
+              return transition?.started === true
             }
-          }
-        } catch {}
+          } catch {}
+          return false
+        })()
 
         // a worker that cannot answer within the remaining budget is busy, not
         // idle: its poll reads as unsettled. bounding each read by the budget
@@ -129,17 +145,51 @@ export async function waitForSootsimIdle({
           let nodeCount = null
           let renderStatsAvailable = false
           let shellAnimating = false
+          let shellBlockers = ''
           let webViewStarting = false
           let webViewBlocker = ''
+          // the reads are independent, so they run concurrently: a loaded sim
+          // answers each one late, and a poll that waits for them in turn
+          // costs their sum, which fits too few polls in the budget to settle.
           // strict also waits out shell motion: a system alert, sheet or menu
           // animates in the shell worker while the app's own stats read still,
           // so its presentation is complete only once the shell's list empties.
-          if (strict) {
-            const motion = await answer(() => window.__sootsimTest?.listAnimations?.()).catch(() => null)
+          const motionRead = strict
+            ? answer(() => window.__sootsimTest?.listAnimations?.()).catch(() => null)
+            : null
+          const statsRead = answer(() => window.__sootsimRenderHost?.queryStats?.()).catch(() => null)
+          // image preparation ends in the tenant before the compositor decodes
+          // and realizes its pixels. both owners must finish before settling.
+          // the compositor rejects a stats request it is too busy to answer.
+          const compositorRead = answer(() => window.__sootsimCompositor.getStats()).catch(() => BUSY)
+          const countsRead = Promise.resolve().then(() => window.__sootsimTest?.getRequestCounts?.()).catch(() => null)
+          // mounted-root membership: the live node count moves while the tree
+          // mounts, unmounts or recycles, in either render mode.
+          const nodeCountRead = Promise.resolve().then(() => window.__sootsimTest?.getNodeCount?.()).catch(() => null)
+          // the mounted hierarchy in render-worker mode comes from the test
+          // bridge: window.__sootsimRoot is an empty placeholder there, so a
+          // walk over it hashes every screen to the same empty string while
+          // it moves. listInspectable is the worker-backed read describe
+          // uses; a worker too busy to answer it reads as unsettled. tight
+          // budgets skip this read and settle on the cheaper signals above.
+          const hierarchyRead =
+            fullGeometry && typeof window.__sootsimTest?.listInspectable === 'function'
+              ? answer(() => window.__sootsimTest.listInspectable({})).catch(() => null)
+              : null
+          if (motionRead) {
+            const motion = await motionRead
             if (motion === BUSY) workerBusy = true
-            else shellAnimating = Array.isArray(motion) && motion.some((anim) => anim.realm === 'shell' && anim.priority !== 'low')
+            else if (Array.isArray(motion)) {
+              const blocking = motion.filter((anim) => anim.realm === 'shell' && anim.priority !== 'low')
+              shellAnimating = blocking.length > 0
+              // name what holds the settle so a timeout points at its owner.
+              shellBlockers = blocking
+                .slice(0, 4)
+                .map((anim) => anim.source + '/' + anim.kind + '#' + anim.id + ' at ' + anim.current + (anim.loop ? ' loop' : ''))
+                .join(', ')
+            }
           }
-          const stats = await answer(() => window.__sootsimRenderHost?.queryStats?.()).catch(() => null)
+          const stats = await statsRead
           if (stats === BUSY) {
             workerBusy = true
           } else if (stats) {
@@ -176,10 +226,7 @@ export async function waitForSootsimIdle({
             // mounting or remounting, even with no animation flag raised.
             appCommits = typeof stats.appCommitCount === 'number' ? stats.appCommitCount : null
           }
-          // image preparation ends in the tenant before the compositor decodes
-          // and realizes its pixels. both owners must finish before settling.
-          // the compositor rejects a stats request it is too busy to answer.
-          const compositor = await answer(() => window.__sootsimCompositor.getStats()).catch(() => BUSY)
+          const compositor = await compositorRead
           if (compositor === BUSY) {
             workerBusy = true
           } else {
@@ -190,31 +237,12 @@ export async function waitForSootsimIdle({
               webViewBlocker = 'compositor webView capture not settled'
             }
           }
-          try {
-            const counts = await window.__sootsimTest?.getRequestCounts?.()
-            requestTotal = typeof counts?.total === 'number' ? counts.total : 0
-            requestInFlight = typeof counts?.inFlight === 'number' ? counts.inFlight : 0
-          } catch {}
-          // mounted-root membership: the live node count moves while the tree
-          // mounts, unmounts or recycles, in either render mode.
-          try {
-            const total = await window.__sootsimTest?.getNodeCount?.()
-            nodeCount = typeof total === 'number' ? total : null
-          } catch {}
-          // the mounted hierarchy in render-worker mode comes from the test
-          // bridge: window.__sootsimRoot is an empty placeholder there, so a
-          // walk over it hashes every screen to the same empty string while
-          // it moves. listInspectable is the worker-backed read describe
-          // uses; a worker too busy to answer it reads as unsettled. tight
-          // budgets skip this read and settle on the cheaper signals above.
-          let hierarchy = null
-          if (fullGeometry && typeof window.__sootsimTest?.listInspectable === 'function') {
-            try {
-              hierarchy = await answer(() => window.__sootsimTest.listInspectable({}))
-            } catch {
-              hierarchy = null
-            }
-          }
+          const counts = await countsRead
+          requestTotal = typeof counts?.total === 'number' ? counts.total : 0
+          requestInFlight = typeof counts?.inFlight === 'number' ? counts.inFlight : 0
+          const total = await nodeCountRead
+          nodeCount = typeof total === 'number' ? total : null
+          let hierarchy = hierarchyRead ? await hierarchyRead : null
           if (hierarchy === BUSY) {
             workerBusy = true
             hierarchy = null
@@ -290,7 +318,7 @@ export async function waitForSootsimIdle({
               pixelFrameToken = token
             }
           }
-          return { layout: nodes.join(';'), screenPixels, animating, shellAnimating, layoutDirty, pendingFetches, workerBusy, webViewStarting, webViewBlocker, renderStatsAvailable, requestTotal, requestInFlight, appCommits, nodeCount }
+          return { layout: nodes.join(';'), screenPixels, animating, shellAnimating, shellBlockers, layoutDirty, pendingFetches, workerBusy, webViewStarting, webViewBlocker, renderStatsAvailable, requestTotal, requestInFlight, appCommits, nodeCount }
         }
 
         // how long generic background network is allowed to keep us waiting AFTER
@@ -377,6 +405,19 @@ export async function waitForSootsimIdle({
               Date.now() - visuallyStillSince >= requiredStillMs &&
               (networkQuiet || Date.now() - visuallyStillSince >= networkQuietGraceMs)
             ) {
+              if (transitionWait) {
+                const started = await transitionWait
+                transitionWait = null
+                if (started) {
+                  lastLayout = ''
+                  lastRequestTotal = -1
+                  lastAppCommits = null
+                  lastNodeCount = null
+                  stable = 0
+                  visuallyStillSince = 0
+                  continue
+                }
+              }
               return { settled: true, elapsed: Date.now() - start, blockedBy: '' }
             }
           } else {
@@ -395,7 +436,7 @@ export async function waitForSootsimIdle({
         const blockers = []
         if (strict && !last.renderStatsAvailable) blockers.push('render stats unavailable')
         if (last.animating) blockers.push('animations still running')
-        if (last.shellAnimating) blockers.push('shell animations still running')
+        if (last.shellAnimating) blockers.push('shell animations still running (' + last.shellBlockers + ')')
         if (last.layoutDirty) blockers.push('layout still dirty')
         if (last.appCommits !== null && lastAppCommits !== null && last.appCommits !== lastAppCommits) blockers.push('layout commits still landing')
         if (last.nodeCount !== null && lastNodeCount !== null && last.nodeCount !== lastNodeCount) blockers.push('node count still changing')
@@ -426,12 +467,7 @@ export async function waitForSootsimIdle({
       },
     )
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    return {
-      settled: false,
-      elapsed: maxMs,
-      blockedBy: message,
-    }
+    throw new IdleObservationError(Math.max(0, Date.now() - observationStartedAt), error)
   }
 
   if (

package/cli/commands/inspect/wait-idle.ts

@@ -1,6 +1,6 @@
-import { rnxExit } from '../../run-rnx'
+import { rethrowIfExit, rnxExit } from '../../run-rnx'
 import { resolveMaxMsFlag } from './core'
-import { waitForSootsimIdle } from './settling'
+import { IdleObservationError, waitForSootsimIdle } from './settling'
 import type { WsBridge } from '../../ws-bridge'
 
 // alias for `do settle` under the discoverable `wait` verb grouping.
@@ -15,12 +15,24 @@ export async function runWaitIdleSubcommand(opts: {
   const { bridge, args } = opts
   const strict = args.includes('--strict')
   const maxMs = resolveMaxMsFlag(args, 3000)
-  const { elapsed, settled } = await waitForSootsimIdle({ bridge, maxMs, strict })
-
-  if (settled) {
-    console.log(`  idle in ${elapsed}ms`)
-  } else {
-    console.error(`  ⚠ wait idle timed out after ${elapsed}ms (may still be animating)`)
-    rnxExit(1)
+  try {
+    const { elapsed, settled, blockedBy } = await waitForSootsimIdle({
+      bridge,
+      maxMs,
+      strict,
+    })
+    if (settled) {
+      console.log(`  idle in ${elapsed}ms`)
+    } else {
+      console.error(`  ⚠ wait idle timed out after ${elapsed}ms (${blockedBy})`)
+      rnxExit(1)
+    }
+  } catch (error) {
+    rethrowIfExit(error)
+    if (error instanceof IdleObservationError) {
+      console.error(`  ⚠ ${error.message}`)
+      rnxExit(1)
+    }
+    throw error
   }
 }

package/cli/commands/inspect/wait-ready.ts

@@ -5,7 +5,7 @@ import {
   type WaitReadyStatus,
   waitReadyReason,
 } from './core'
-import { waitReadyAndSettle } from './settling'
+import { IdleObservationError, waitReadyAndSettle } from './settling'
 import type { WsBridge } from '../../ws-bridge'
 
 // blocks until the guest app bundle has finished loading and painted real
@@ -29,13 +29,27 @@ export async function runWaitReadySubcommand(opts: {
     printReady(status, status.elapsedMs)
     return
   }
-  const { status, idle, elapsedMs } = await waitReadyAndSettle(bridge, timeoutMs, {
-    onProgress(progress) {
-      console.error(
-        `  still waiting after ${progress.elapsedMs}ms — ${waitReadyReason(progress)} (nodes: ${progress.nodes}, targets: ${progress.targets}, live surfaces: ${progress.liveFrameActive ? progress.liveFrameChannels : 0}, browser surfaces: ${progress.browserSurfaceCount}, errors: ${progress.errors})`,
-      )
-    },
-  })
+  let status: Awaited<ReturnType<typeof waitReadyAndSettle>>['status']
+  let idle: Awaited<ReturnType<typeof waitReadyAndSettle>>['idle']
+  let elapsedMs: number
+  try {
+    const settledWait = await waitReadyAndSettle(bridge, timeoutMs, {
+      onProgress(progress) {
+        console.error(
+          `  still waiting after ${progress.elapsedMs}ms — ${waitReadyReason(progress)} (nodes: ${progress.nodes}, targets: ${progress.targets}, live surfaces: ${progress.liveFrameActive ? progress.liveFrameChannels : 0}, browser surfaces: ${progress.browserSurfaceCount}, errors: ${progress.errors})`,
+        )
+      },
+    })
+    status = settledWait.status
+    idle = settledWait.idle
+    elapsedMs = settledWait.elapsedMs
+  } catch (error) {
+    if (error instanceof IdleObservationError) {
+      console.error(`  ⚠ ${error.message}`)
+      rnxExit(1)
+    }
+    throw error
+  }
   if (!idle) timedOut(status, elapsedMs)
   if (!idle.settled) {
     console.error(