peachsim 0.1.527

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

@@ -0,0 +1,59 @@
+import { rnxExit } from '../../run-rnx'
+import { inspectWaitSelector } from './core'
+import type { WsBridge } from '../../ws-bridge'
+
+// blocks until a node with the given testID is visible and laid out, or — with
+// `--gone` — until it is absent. `--structural` drops the visibility test and
+// waits only for the node to exist, which is what a marker rendered as proof
+// (a build id, a launch phase) needs: it is 1x1 and painted under the app, so
+// it is permanently occluded and the visible check can never match it. the
+// engine owns the polling loop and this handler sends one request, then
+// reports.
+export async function runWaitSelectorSubcommand(opts: {
+  bridge: WsBridge
+  args: string[]
+  positional: string[]
+  inspectUsage: (name: string, tail: string) => string
+}): Promise<void> {
+  const { bridge, args, positional, inspectUsage } = opts
+  const testId = positional[1]
+  if (!testId) {
+    console.error(
+      inspectUsage('selector', '<testid> [--max-ms 5000] [--gone] [--structural]'),
+    )
+    rnxExit(1)
+  }
+  const maxMsIdx = args.indexOf('--max-ms')
+  const timeoutMs =
+    maxMsIdx >= 0 && args[maxMsIdx + 1] ? Math.max(100, Number(args[maxMsIdx + 1])) : 5000
+  const gone = args.includes('--gone')
+  const structural = args.includes('--structural')
+
+  const { found, node, elapsed } = await inspectWaitSelector(bridge, testId, timeoutMs, {
+    gone,
+    structural,
+  })
+
+  if (gone) {
+    if (found) {
+      console.log(`  #${testId} gone after ${elapsed}ms`)
+    } else {
+      console.error(
+        `  ⚠ wait selector #${testId} --gone timed out after ${elapsed ?? timeoutMs}ms (still present)`,
+      )
+      rnxExit(1)
+    }
+    return
+  }
+
+  if (found && node) {
+    const loc = `@(${Math.round(node.geometry.x)},${Math.round(node.geometry.y)})`
+    const size = `${Math.round(node.geometry.width)}x${Math.round(node.geometry.height)}`
+    console.log(`  found #${testId} in ${elapsed}ms ${size} ${loc}`)
+  } else {
+    console.error(
+      `  ⚠ wait selector #${testId} timed out after ${elapsed ?? timeoutMs}ms`,
+    )
+    rnxExit(1)
+  }
+}

package/cli/commands/inspect/wait.ts

@@ -0,0 +1,32 @@
+import { rememberFlowCandidate } from '../../flow-session'
+import { rnxExit } from '../../run-rnx'
+import { waitForSimReady } from './shared'
+
+export async function runWaitSubcommand(opts: {
+  wsPort: number
+  commandTimeoutMs: number
+  simId?: string
+  simIdSource?: 'flag' | 'saved' | 'none'
+  positional: string[]
+}): Promise<void> {
+  const { wsPort, commandTimeoutMs, simId, simIdSource, positional } = opts
+  const seconds = positional[1] ? Number(positional[1]) : 30
+  const timeoutMs = Math.max(1000, (Number.isFinite(seconds) ? seconds : 30) * 1000)
+  const attempts = Math.max(1, Math.ceil(timeoutMs / 500))
+  console.log(`  waiting for sim reconnect...`)
+  const ready = await waitForSimReady(wsPort, commandTimeoutMs, simId, {
+    attempts,
+    simIdSource,
+  })
+  if (!ready) {
+    console.error(`  timed out waiting for sim reconnect`)
+    rnxExit(1)
+  }
+  ready.bridge.close()
+  rememberFlowCandidate({
+    source: 'inspect wait',
+    step: { wait: timeoutMs },
+    summary: `wait ${Math.round(timeoutMs / 1000)}s`,
+  })
+  console.log(`  ready: ${ready.count} nodes`)
+}