peachsim 0.1.939 → 0.1.1399

package/cli/commands/inspect/core.ts

@@ -13,7 +13,6 @@
 
 import {
   HEADLESS_TENANT_FETCH_HUNG_MARKER,
-  PUBLIC_NO_NETWORK_MARKER,
   readyProbeIsReady,
   type SemanticWaitResult,
   type WsBridgeCommand,
@@ -1197,10 +1196,7 @@ export function waitReadyReason(
   > & { bridgeError?: string },
 ): string {
   if (status.bridgeError) {
-    if (
-      status.bridgeError.includes(HEADLESS_TENANT_FETCH_HUNG_MARKER) ||
-      status.bridgeError.includes(PUBLIC_NO_NETWORK_MARKER)
-    ) {
+    if (status.bridgeError.includes(HEADLESS_TENANT_FETCH_HUNG_MARKER)) {
       return status.bridgeError
     }
     return `sim unreachable: ${status.bridgeError} — the target tab is closed or no sim is connected (check \`peach list\`, reopen with \`peach open\`)`
@@ -1269,7 +1265,7 @@ export async function inspectCaptureReady(
 }
 
 // how long one snapshot request may take to cross the bridge and read once
-const READY_SNAPSHOT_SEND_TIMEOUT_MS = 2_000
+const READY_SNAPSHOT_SEND_TIMEOUT_MS = 15_000
 
 // one readiness probe, judged on its own: no stability window, since the
 // caller has already let the app settle. any runtime answers it: a wait that
@@ -1286,8 +1282,18 @@ export async function inspectReadySnapshot(
   const deadline = Date.now() + budgetMs
   let result: SemanticWaitResult
   do {
-    result = await sendReadyWait(bridge, 1, READY_SNAPSHOT_SEND_TIMEOUT_MS, simId)
-  } while (result.polls !== 1 && !result.error && Date.now() < deadline)
+    const remaining = Math.max(0, deadline - Date.now())
+    const sendTimeoutMs = Math.max(
+      READY_SNAPSHOT_SEND_TIMEOUT_MS,
+      Math.min(remaining, 60_000),
+    )
+    result = await sendReadyWait(bridge, 1, sendTimeoutMs, simId)
+  } while (
+    result.polls !== 1 &&
+    !result.error?.startsWith('sim disconnected') &&
+    !result.error?.startsWith('bridge never reconnected') &&
+    Date.now() < deadline
+  )
   return waitReadyStatus(
     result,
     result.polls === 1 && result.probe ? readyProbeIsReady(result.probe) : false,

package/cli/commands/inspect/list.ts

@@ -154,7 +154,7 @@ function printConnectedSims(sims: BridgeSimInfo[], selectedId?: string) {
 // classify which engine a sim is running so dev-vs-published is never ambiguous
 // to agents or humans reading `peach list`. dev shell serves local source on
 // :5173; the Contrast app embeds peach on :3000; the bridge/daemon and the
-// /__soot plugin serve the active runtime dir — which, inside a dev checkout, is
+// /__peachsim plugin serve the active runtime dir — which, inside a dev checkout, is
 // the fresh dev-stack build (resolveDevCheckoutRuntimeRoot mode boundary), not a
 // published runtime. keep this label honest so it never says "published" while
 // actually serving local build output.

package/cli/commands/inspect/settle.ts

@@ -1,9 +1,11 @@
 import { waitForSootsimIdle } from './settling'
 import type { WsBridge } from '../../ws-bridge'
 
-// default: layout hash stable for 3 consecutive polls. --strict additionally
-// requires worker queryStats animation flags to be false — use when the
-// target app has no perpetual background animation.
+// default: worker stillness plus mounted-root membership; budgets of a
+// second or more also confirm the mounted geometry. --strict additionally
+// requires shell motion to clear and rejects runtimes without blocking
+// animation stats — use when the target app has no perpetual background
+// animation.
 export async function runSettleSubcommand(opts: {
   bridge: WsBridge
   args: string[]

package/cli/commands/inspect/settling.ts

@@ -30,6 +30,20 @@ export type WaitForSootsimIdleResult = {
   blockedBy: string
 }
 
+export class RuntimeReadinessUnsupportedError extends Error {
+  readonly code = 'runtime_readiness_unsupported'
+
+  constructor(
+    readonly runtimeVersion: string,
+    readonly missingFields: string[],
+  ) {
+    super(
+      `runtime ${runtimeVersion} cannot report animation readiness (${missingFields.join(', ')} missing); run \`peach upgrade\` and reopen the simulator`,
+    )
+    this.name = 'RuntimeReadinessUnsupportedError'
+  }
+}
+
 export async function waitForSootsimIdle({
   bridge,
   simId,
@@ -39,16 +53,23 @@ export async function waitForSootsimIdle({
   strict = false,
   paintStill = false,
 }: WaitForSootsimIdleOptions): Promise<WaitForSootsimIdleResult> {
-  const result = await bridge.send(
-    {
-      type: 'evaluate',
-      simId,
-      code: `(async () => {
+  let result: any
+  try {
+    result = await bridge.send(
+      {
+        type: 'evaluate',
+        simId,
+        code: `(async () => {
       const start = Date.now()
       const deadline = start + ${Math.max(0, Math.round(maxMs))}
       const pollMs = ${Math.max(1, Math.round(pollMs))}
       const strict = ${strict ? 'true' : 'false'}
       const paintStill = ${paintStill ? 'true' : 'false'}
+      // full mounted-geometry observation needs at least two hierarchy reads
+      // plus the stillness window, which a sub-second budget cannot afford:
+      // tight budgets (auto-wait) settle on worker stillness plus root
+      // membership, generous ones confirm the geometry too.
+      const fullGeometry = ${maxMs >= 1000 ? 'true' : 'false'}
       const requiredStillMs = paintStill ? 0 : ${Math.max(1, Math.round(stablePolls)) * Math.max(1, Math.round(pollMs))}
       const minimumStablePolls = paintStill ? 1 : ${Math.min(2, Math.max(1, Math.round(stablePolls)))}
       const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
@@ -85,58 +106,177 @@ export async function waitForSootsimIdle({
           }
         } catch {}
 
+        // a worker that cannot answer within the remaining budget is busy, not
+        // idle: its poll reads as unsettled. bounding each read by the budget
+        // keeps a busy worker from holding a poll past the deadline.
+        const BUSY = { busy: true }
+        const answer = (read) =>
+          Promise.race([
+            Promise.resolve().then(read),
+            new Promise((resolve) =>
+              setTimeout(() => resolve(BUSY), Math.max(deadline - Date.now(), 100)),
+            ),
+          ])
+
         const readSnapshot = async () => {
           let animating = false
           let layoutDirty = false
           let pendingFetches = 0
+          let workerBusy = false
           let requestTotal = 0
           let requestInFlight = 0
+          let appCommits = null
+          let nodeCount = null
           let renderStatsAvailable = false
           let shellAnimating = false
+          let webViewStarting = false
+          let webViewBlocker = ''
           // 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) {
-            try {
-              const motion = await window.__sootsimTest?.listAnimations?.()
-              shellAnimating = Array.isArray(motion) && motion.some((anim) => anim.realm === 'shell')
-            } catch {}
+            const motion = await answer(() => window.__sootsimTest?.listAnimations?.()).catch(() => null)
+            if (motion === BUSY) workerBusy = true
+            else shellAnimating = Array.isArray(motion) && motion.some((anim) => anim.realm === 'shell' && anim.priority !== 'low')
           }
-          try {
-            const stats = await window.__sootsimRenderHost?.queryStats?.()
-            if (stats) {
-              renderStatsAvailable = true
-              animating =
-                stats.hasActiveAnims === true ||
-                stats.hasActiveNativeAnimations === true ||
-                stats.hasPendingAnimationFrames === true
-              layoutDirty =
-                stats.layoutDirty === true && stats.renderRequested === true
-              // a freshly-pushed screen showing a skeleton is layout-stable
-              // but not actually settled — its data/images are still in
-              // flight. treat bounded image-loader fetches as not-idle so
-              // settle waits for real content, capped by the budget.
-              const pf = stats.memory && stats.memory.imageLoader
-                ? stats.memory.imageLoader.pendingFetches
-                : 0
-              pendingFetches = typeof pf === 'number' ? pf : 0
+          const stats = await answer(() => window.__sootsimRenderHost?.queryStats?.()).catch(() => null)
+          if (stats === BUSY) {
+            workerBusy = true
+          } else if (stats) {
+            renderStatsAvailable = true
+            const missingFields = ['hasActiveBlockingNativeAnimations', 'hasPendingBlockingAnimationFrames']
+              .filter((field) => typeof stats[field] !== 'boolean')
+            if (strict && missingFields.length > 0) {
+              return {
+                runtimeUnsupported: {
+                  error: 'runtime_readiness_unsupported',
+                  runtimeVersion: window.__sootsimRuntimeVersion || 'unknown',
+                  missingFields,
+                },
+              }
             }
-          } catch {}
+            // positive checks only: an older runtime without the blocking
+            // fields reads as still, and strict rejects that runtime above
+            // instead of ever settling on unknown motion.
+            animating =
+              stats.hasActiveAnims === true ||
+              stats.hasActiveBlockingNativeAnimations === true ||
+              stats.hasPendingBlockingAnimationFrames === true
+            layoutDirty =
+              stats.layoutDirty === true && stats.renderRequested === true
+            // a freshly-pushed screen showing a skeleton is layout-stable
+            // but not actually settled — its data/images are still in
+            // flight. treat bounded image-loader fetches as not-idle so
+            // settle waits for real content, capped by the budget.
+            const pf = stats.memory && stats.memory.imageLoader
+              ? stats.memory.imageLoader.pendingFetches
+              : 0
+            pendingFetches = typeof pf === 'number' ? pf : 0
+            // tenant layout commits: a screen that keeps committing is still
+            // 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)
+          if (compositor === BUSY) {
+            workerBusy = true
+          } else {
+            pendingFetches += compositor.images.pendingFetches
+            pendingFetches += compositor.imageRealization.pending
+            if (compositor.webViewCaptureSettled === false) {
+              webViewStarting = true
+              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 {}
-          const root = window.__sootsimRoot
+          // 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
+            }
+          }
+          if (hierarchy === BUSY) {
+            workerBusy = true
+            hierarchy = null
+          } else if (!Array.isArray(hierarchy)) {
+            hierarchy = null
+          }
           const nodes = []
-          if (root) {
-            const walk = (n) => {
-              if (n.layout && n.layout.width > 0) {
-                nodes.push(Math.round(n.layout.x) + ',' + Math.round(n.layout.y) + ',' + Math.round(n.layout.width))
+          const PREVIEW_PROGRESS_REGEX = /^(creating webview|loading html|fetching bundle|waiting for first render|starting preview|loading simulator|fetching app code|waiting for native preview|starting design|loading canvas|fetching screens|painting the canvas|waiting for webview|waiting for preview|waiting for canvas|preview stalled)/i
+          const notePreviewProgress = (tid, text) => {
+            if (typeof tid === 'string' && (tid === 'web-preview-progress' || tid.endsWith('-preview-progress'))) {
+              webViewStarting = true
+              if (!webViewBlocker) webViewBlocker = 'preview progress active (' + tid + ')'
+            }
+            if (typeof text === 'string' && PREVIEW_PROGRESS_REGEX.test(text.trim())) {
+              webViewStarting = true
+              if (!webViewBlocker) webViewBlocker = 'webView startup in progress ("' + text.trim() + '")'
+            }
+          }
+          if (hierarchy) {
+            for (const n of hierarchy) {
+              const layout = n && n.layout
+              if (layout && layout.width > 0) {
+                const abs = (n && (n.absolute || n.absolutePosition)) || layout
+                nodes.push(Math.round(abs.x) + ',' + Math.round(abs.y) + ',' + Math.round(layout.width))
+              }
+              notePreviewProgress(
+                n.testID || n.testId,
+                typeof n.text === 'string' ? n.text : '',
+              )
+            }
+          } else {
+            const root = window.__sootsimRoot
+            if (root) {
+              const walk = (n) => {
+                if (n.layout && n.layout.width > 0) {
+                  nodes.push(Math.round(n.layout.x) + ',' + Math.round(n.layout.y) + ',' + Math.round(n.layout.width))
+                }
+                notePreviewProgress(
+                  n.testID || n.props?.testID || n.props?.testId,
+                  n.textContent || (typeof n.props?.children === 'string' ? n.props.children : ''),
+                )
+                for (const c of n.children || []) walk(c)
+              }
+              walk(root)
+            }
+          }
+          if (!webViewStarting && typeof document !== 'undefined') {
+            const progressEl = document.querySelector(
+              '[data-testid$="-preview-progress"], [data-testid="web-preview-progress"], [data-testid="ios-preview-progress"], [data-testid="design-preview-progress"]'
+            )
+            if (progressEl) {
+              webViewStarting = true
+              webViewBlocker = 'preview progress element displayed'
+            } else {
+              const unreadyWebView = document.querySelector(
+                '[data-sootsim-webview-loading="true"], [data-sootsim-webview-mode="placeholder"]'
+              )
+              if (unreadyWebView) {
+                webViewStarting = true
+                webViewBlocker = 'webView document still loading'
               }
-              for (const c of n.children || []) walk(c)
             }
-            walk(root)
           }
           if (paintStill) {
             const canvas = composite.getCanvas()
@@ -150,7 +290,7 @@ export async function waitForSootsimIdle({
               pixelFrameToken = token
             }
           }
-          return { layout: nodes.join(';'), screenPixels, animating, shellAnimating, layoutDirty, pendingFetches, renderStatsAvailable, requestTotal, requestInFlight }
+          return { layout: nodes.join(';'), screenPixels, animating, shellAnimating, layoutDirty, pendingFetches, workerBusy, webViewStarting, webViewBlocker, renderStatsAvailable, requestTotal, requestInFlight, appCommits, nodeCount }
         }
 
         // how long generic background network is allowed to keep us waiting AFTER
@@ -168,6 +308,8 @@ export async function waitForSootsimIdle({
         let lastScreenPixels = null
         let screenChangedPolls = 0
         let lastRequestTotal = -1
+        let lastAppCommits = null
+        let lastNodeCount = null
         let stable = 0
         let visuallyStillSince = 0
         // counts across the whole budget: a flag that is true on every poll is a
@@ -177,6 +319,7 @@ export async function waitForSootsimIdle({
         let dirtyPolls = 0
         let animatingPolls = 0
         let layoutChangedPolls = 0
+        let webViewStartingPolls = 0
         const screenUnchanged = (pixels) => {
           if (!pixels || !lastScreenPixels || pixels.width !== lastScreenPixels.width || pixels.height !== lastScreenPixels.height) return false
           if (pixels === lastScreenPixels) return true
@@ -187,9 +330,11 @@ export async function waitForSootsimIdle({
         }
         while (Date.now() < deadline) {
           const snapshot = await readSnapshot()
+          if (snapshot.runtimeUnsupported) return snapshot.runtimeUnsupported
           polls++
           if (snapshot.layoutDirty) dirtyPolls++
           if (snapshot.animating || snapshot.shellAnimating) animatingPolls++
+          if (snapshot.webViewStarting) webViewStartingPolls++
           if (polls > 1 && snapshot.layout !== lastLayout) layoutChangedPolls++
           const screenChanged = paintStill && !screenUnchanged(snapshot.screenPixels)
           if (polls > 1 && screenChanged) screenChangedPolls++
@@ -199,12 +344,24 @@ export async function waitForSootsimIdle({
               !snapshot.animating &&
               !snapshot.shellAnimating &&
               !snapshot.layoutDirty)
-          // visually settled: no animations, no image content loading, layout
-          // unchanged since the last poll.
+          // visually settled: no worker motion or layout work, no new layout
+          // commits, a stable mounted node count, no image content loading,
+          // no webview startup in progress, layout unchanged since the last
+          // poll. both modes wait out finite worker motion now; strict
+          // additionally implies the flags through strictOk and adds shell
+          // motion plus the blocking-stats floor. a null count or commit
+          // reading means the runtime does not report it, which reads as
+          // stable the way a missing stats block does.
           const visuallyStill =
             strictOk &&
+            !snapshot.animating &&
+            !snapshot.layoutDirty &&
+            (snapshot.appCommits === null || lastAppCommits === null || snapshot.appCommits === lastAppCommits) &&
+            (snapshot.nodeCount === null || lastNodeCount === null || snapshot.nodeCount === lastNodeCount) &&
             !screenChanged &&
             snapshot.pendingFetches === 0 &&
+            !snapshot.workerBusy &&
+            !snapshot.webViewStarting &&
             snapshot.layout === lastLayout
           // generic network quiet: nothing in flight and no new requests issued.
           const networkQuiet =
@@ -229,15 +386,22 @@ export async function waitForSootsimIdle({
           lastLayout = snapshot.layout
           lastScreenPixels = snapshot.screenPixels
           lastRequestTotal = snapshot.requestTotal
+          lastAppCommits = snapshot.appCommits
+          lastNodeCount = snapshot.nodeCount
           await sleep(pollMs)
         }
         const last = await readSnapshot()
+        if (last.runtimeUnsupported) return last.runtimeUnsupported
         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.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')
         if (last.pendingFetches > 0) blockers.push(last.pendingFetches + ' image fetches pending')
+        if (last.workerBusy) blockers.push('a render worker too busy to report')
+        if (last.webViewStarting) blockers.push(last.webViewBlocker || 'webView still starting')
         if (last.layout !== lastLayout) blockers.push('layout still changing')
         if (paintStill && !last.screenPixels) blockers.push('screen pixels unavailable')
         else if (paintStill && !screenUnchanged(last.screenPixels)) blockers.push('screen pixels still changing')
@@ -250,17 +414,37 @@ export async function waitForSootsimIdle({
           blockedBy:
             (blockers.length ? blockers.join(', ') : 'unknown') +
             ' over ' + polls + ' polls (layout changed ' + layoutChangedPolls +
-            'x, layoutDirty ' + dirtyPolls + 'x, animating ' + animatingPolls + 'x, screen changed ' + screenChangedPolls + 'x)',
+            'x, layoutDirty ' + dirtyPolls + 'x, animating ' + animatingPolls + 'x, webViewStarting ' + webViewStartingPolls + 'x, screen changed ' + screenChangedPolls + 'x)',
         }
       } finally {
         unsubscribe?.()
       }
     })()`,
-    },
-    {
-      timeoutMs: maxMs + 1_000,
-    },
-  )
+      },
+      {
+        timeoutMs: Math.max(5_000, maxMs + 2_000),
+      },
+    )
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    return {
+      settled: false,
+      elapsed: maxMs,
+      blockedBy: message,
+    }
+  }
+
+  if (
+    result?.error === 'runtime_readiness_unsupported' &&
+    typeof result.runtimeVersion === 'string' &&
+    Array.isArray(result.missingFields) &&
+    result.missingFields.every((field: unknown) => typeof field === 'string')
+  ) {
+    throw new RuntimeReadinessUnsupportedError(
+      result.runtimeVersion,
+      result.missingFields,
+    )
+  }
 
   const { elapsed, settled, blockedBy } = (result ??
     {}) as Partial<WaitForSootsimIdleResult>
@@ -299,6 +483,7 @@ export async function waitReadyAndSettle(
   })
   let idle: WaitForSootsimIdleResult | null = null
   for (;;) {
+    idle = null
     const ready = await inspectWaitReady(bridge, remaining(), options)
     if (!ready.ready) return result(ready, idle)
     idle = await waitForSootsimIdle({

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

@@ -4,8 +4,9 @@ import { waitForSootsimIdle } from './settling'
 import type { WsBridge } from '../../ws-bridge'
 
 // alias for `do settle` under the discoverable `wait` verb grouping.
-// layout hash stability across 3 polls; --strict also requires the app's
-// animation flags clear and no shell motion (alerts, sheets, menus).
+// worker stillness plus mounted-root membership; budgets of a second or
+// more also confirm the mounted geometry. --strict also requires shell
+// motion clear (alerts, sheets, menus) and blocking animation stats.
 export async function runWaitIdleSubcommand(opts: {
   bridge: WsBridge
   args: string[]