peachsim 0.1.939 → 0.1.1399

package/dist-lib/sdk.mjs

@@ -1,11 +1,10 @@
-/*! rnx v0.1.939 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! peach v0.1.1399 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/bridge-contract.ts
 var SEMANTIC_READY_CONTENT_NODE_FLOOR = 100;
-var PUBLIC_NO_NETWORK_MARKER = "public Peach Cloud simulators have no network";
 var HEADLESS_TENANT_FETCH_HUNG_MARKER = "headless tenant fetch hung";
 function readyProbeHasContent(probe) {
   return (probe.browserSurfaceCount ?? 0) > 0 || probe.liveFrameActive || probe.targets > 0 || probe.nodes >= SEMANTIC_READY_CONTENT_NODE_FLOOR;
@@ -746,7 +745,7 @@ function shellEscape(value) {
 }
 function waitReadyReason(status) {
   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} \u2014 the target tab is closed or no sim is connected (check \`peach list\`, reopen with \`peach open\`)`;
@@ -766,13 +765,18 @@ async function inspectCaptureReady(bridge, timeoutMs) {
   if (snapshot.ready) return snapshot;
   return inspectWaitReady(bridge, timeoutMs);
 }
-var READY_SNAPSHOT_SEND_TIMEOUT_MS = 2e3;
+var READY_SNAPSHOT_SEND_TIMEOUT_MS = 15e3;
 async function inspectReadySnapshot(bridge, budgetMs, simId) {
   const deadline = Date.now() + budgetMs;
   let result;
   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, 6e4)
+    );
+    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
@@ -1416,6 +1420,17 @@ async function resolveTargetCoords(bridge, target) {
 }
 
 // cli/commands/inspect/settling.ts
+var RuntimeReadinessUnsupportedError = class extends Error {
+  constructor(runtimeVersion, missingFields) {
+    super(
+      `runtime ${runtimeVersion} cannot report animation readiness (${missingFields.join(", ")} missing); run \`peach upgrade\` and reopen the simulator`
+    );
+    this.runtimeVersion = runtimeVersion;
+    this.missingFields = missingFields;
+    __publicField(this, "code", "runtime_readiness_unsupported");
+    this.name = "RuntimeReadinessUnsupportedError";
+  }
+};
 async function waitForSootsimIdle({
   bridge,
   simId,
@@ -1425,16 +1440,23 @@ async function waitForSootsimIdle({
   strict = false,
   paintStill = false
 }) {
-  const result = await bridge.send(
-    {
-      type: "evaluate",
-      simId,
-      code: `(async () => {
+  let result;
+  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 >= 1e3 ? "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))
@@ -1471,58 +1493,177 @@ 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 \u2014 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 \u2014 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()
@@ -1536,7 +1677,7 @@ 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
@@ -1554,6 +1695,8 @@ 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
@@ -1563,6 +1706,7 @@ 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
@@ -1573,9 +1717,11 @@ 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++
@@ -1585,12 +1731,24 @@ 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 =
@@ -1615,15 +1773,22 @@ 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')
@@ -1636,17 +1801,31 @@ 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 + 1e3
-    }
-  );
+      },
+      {
+        timeoutMs: Math.max(5e3, maxMs + 2e3)
+      }
+    );
+  } 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) => typeof field === "string")) {
+    throw new RuntimeReadinessUnsupportedError(
+      result.runtimeVersion,
+      result.missingFields
+    );
+  }
   const { elapsed, settled, blockedBy } = result ?? {};
   return {
     elapsed: typeof elapsed === "number" ? elapsed : maxMs,
@@ -1664,6 +1843,7 @@ async function waitReadyAndSettle(bridge, timeoutMs, options = {}) {
   });
   let idle = null;
   for (; ; ) {
+    idle = null;
     const ready = await inspectWaitReady(bridge, remaining(), options);
     if (!ready.ready) return result(ready, idle);
     idle = await waitForSootsimIdle({
@@ -2164,7 +2344,7 @@ function buildSimOpenUrl(currentUrl, target) {
   const url = new URL(currentUrl);
   for (const param of TARGET_SEARCH_PARAMS) url.searchParams.delete(param);
   const pathname = url.pathname.replace(/\/+$/, "") || "/";
-  const prefix = pathname === "/__soot" || pathname.startsWith("/__soot/") ? "/__soot" : "";
+  const prefix = pathname === "/__peachsim" || pathname.startsWith("/__peachsim/") ? "/__peachsim" : "";
   const normalized = String(target).trim();
   if (/^\d+$/.test(normalized)) {
     url.pathname = `${prefix}/rn/${normalized}`;