rnxsim 0.1.365 → 0.1.367

package/cli/commands/inspect/describe.ts

@@ -1,8 +1,4 @@
-// `sootsim describe` — dump the visible-UI tree with layout + style annotations.
-//
-// see packages/sootsim-engine/src/test-bridge.ts for the actual dumpTree impl
-// that powers this. the CLI-side job is just: optional preflight for in-flight
-// screen transitions, call dumpTree with the right flags, and pretty-print.
+// `sootsim describe` — format the pruned visible semantic tree.
 
 import { maybeHint } from '../../hints'
 import { inspectDescribe, type DescribeDumpOptions } from './core'
@@ -34,18 +30,6 @@ export async function runDescribeSubcommand(opts: DescribeOptions): Promise<void
   const watchInterval = 1000
   const compact = args.includes('--compact')
   const hideXy = args.includes('--no-xy')
-  // when set, strip rows annotated `(clipped:left|right|top|bottom)` from the
-  // output. dumpTree marks anything that overflows the viewport so search
-  // context is preserved, but the rows balloon the output on screens like
-  // 3pc's profile (off-screen list items + edge-pulled chrome). this flag is
-  // a client-side filter so we don't need a roundtrip to dumpTree.
-  const hideClipped = args.includes('--no-clipped')
-  // by default describe hides nodes that sit fully behind a modal/sheet/popover
-  // scrim — they aren't reachable, and listing them as `(tap)` misleads agents
-  // into tapping content that's actually occluded. --include-occluded surfaces
-  // them annotated `(behind)`.
-  const includeOccluded = args.includes('--include-occluded')
-
   const testIdLike = flagValue(args, '--testid-like')
   const onlyGlob = flagValue(args, '--only')
   const subtreeRoot = flagValue(args, '--subtree')
@@ -74,35 +58,17 @@ export async function runDescribeSubcommand(opts: DescribeOptions): Promise<void
       subtreeRoot: subtreeRoot || undefined,
       compact,
       hideXy,
-      includeOccluded,
       // no terminal to fit, so nothing gets clipped on the way out
       fullText: jsonOut,
     }
     const result = await inspectDescribe(bridge, dumpOpts)
     const tree = result?.tree
-    const shell = result?.shell
-    const keyboard = result?.keyboard
 
     if (jsonOut) {
-      printJson({ shell, tree: tree ?? '', keyboard })
+      printJson({ tree: tree ?? '' })
       return
     }
 
-    // show shell state in header if available
-    if (shell && typeof shell === 'object') {
-      const shellParts = [
-        shell.state ? `state=${shell.state}` : null,
-        shell.activeApp ? `app=${shell.activeApp}` : null,
-        shell.showSwitcher ? 'switcher' : null,
-        shell.switcherPhase && shell.switcherPhase !== 'idle'
-          ? `phase=${shell.switcherPhase}`
-          : null,
-      ].filter(Boolean)
-      if (shellParts.length > 0) {
-        console.log(`  shell: ${shellParts.join(' ')}`)
-      }
-    }
-
     if (typeof tree === 'string' && tree.startsWith('__SUBTREE_NOT_FOUND__:')) {
       const missing = tree.slice('__SUBTREE_NOT_FOUND__:'.length)
       console.log(`  subtree root not found: ${missing}`)
@@ -120,26 +86,7 @@ export async function runDescribeSubcommand(opts: DescribeOptions): Promise<void
       return
     }
 
-    let rendered = tree
-    let hiddenClippedCount = 0
-    if (hideClipped && typeof rendered === 'string') {
-      const lines = rendered.split('\n')
-      const kept: string[] = []
-      for (const line of lines) {
-        if (line.includes('(clipped:')) {
-          hiddenClippedCount += 1
-          continue
-        }
-        kept.push(line)
-      }
-      rendered = kept.join('\n')
-    }
-    console.log(rendered)
-    if (hiddenClippedCount > 0) {
-      console.log(
-        `  ${hiddenClippedCount} clipped row(s) hidden (omit --no-clipped to see)`,
-      )
-    }
+    console.log(tree)
 
     const anyFilterActive = filter || testIdLike || effectiveOnlyGlob || subtreeRoot
     const searchFilterActive = filter || testIdLike || effectiveOnlyGlob
@@ -157,26 +104,6 @@ export async function runDescribeSubcommand(opts: DescribeOptions): Promise<void
         maybeHint('describe-use-filters')
       }
     }
-
-    // keyboard summary — only when visible. rendered as a footer so it
-    // doesn't bury the tree on forms with non-trivial UI above the input.
-    if (keyboard && keyboard.visible) {
-      const spec = keyboard.spec
-      const kbParts = [
-        spec?.keyboardType ? `type=${spec.keyboardType}` : null,
-        spec?.returnKeyType && spec.returnKeyType !== 'default'
-          ? `return=${spec.returnKeyType}`
-          : null,
-        keyboard.mode !== 'letters' ? `mode=${keyboard.mode}` : null,
-        keyboard.shifted ? 'shift' : null,
-        keyboard.capsLock ? 'caps' : null,
-        spec?.autoCapitalize && spec.autoCapitalize !== 'sentences'
-          ? `autoCap=${spec.autoCapitalize}`
-          : null,
-        keyboard.accessoryBarId ? `accessory=${keyboard.accessoryBarId}` : null,
-      ].filter(Boolean)
-      console.log(`\n  keyboard: ${kbParts.join(' ') || 'visible'}`)
-    }
   }
 
   if (watch) {

package/cli/commands/inspect/find.ts

@@ -1,5 +1,5 @@
 import { maybeHint } from '../../hints'
-import { inspectFind, rankInteractive, tapCommandForNode } from './core'
+import { inspectFind, inspectNodeCount, rankInteractive, tapCommandForNode } from './core'
 import { printJson, wantsJson } from './shared'
 import type { WsBridge } from '../../ws-bridge'
 
@@ -78,11 +78,8 @@ export async function runFindSubcommand(opts: {
   } else if (Array.isArray(result)) {
     if (result.length === 0) {
       console.log(`  no ${mode} nodes found`)
-      const nodeCount = await bridge.send({
-        type: 'evaluate',
-        code: '(async () => (await window.__sootsimTest?.getNodeCount?.()) || 0)()',
-      })
-      if (typeof nodeCount === 'number' && nodeCount < 10) {
+      const { nodes: nodeCount } = await inspectNodeCount(bridge)
+      if (nodeCount < 10) {
         maybeHint('app-still-loading', nodeCount)
       }
     } else if (mode === 'interactive-targets') {

package/cli/commands/inspect/get-layout.ts

@@ -25,7 +25,20 @@ export async function runGetLayoutSubcommand(opts: {
   const styling = args.includes('--styling')
   const filterIndex = args.indexOf('--filter')
   const filter = filterIndex >= 0 ? args[filterIndex + 1] : undefined
-  const elements = await inspectGetLayout(bridge, { styling, filter })
+  const elements = await inspectGetLayout(bridge, { styling, filter }).catch(
+    (error: unknown) => {
+      if (
+        styling &&
+        error instanceof Error &&
+        error.message === 'unsupported RNX Cloud command type: evaluate'
+      ) {
+        throw new Error(
+          'get layout --styling is unavailable in RNX Cloud; rerun without --styling or use a local sim',
+        )
+      }
+      throw error
+    },
+  )
   if (jsonOut) {
     printJson({ count: elements.length, elements })
     return

package/cli/commands/inspect/resolve-target.ts

@@ -1,3 +1,4 @@
+import { isSimSemanticTree } from './core'
 import type { WsBridge } from '../../ws-bridge'
 
 // read a --testid / --text flag from args. returns null when neither is
@@ -26,57 +27,50 @@ export function readTargetFlag(
   return null
 }
 
-export async function resolveTargetCoords(
-  bridge: WsBridge,
-  target: { mode: 'testid' | 'text'; value: string },
-): Promise<{
+export interface ResolvedTargetCoords {
   x: number
   y: number
-  id?: string | null
   testID?: string | null
   text?: string | null
   type?: string | null
-} | null> {
-  const arg = JSON.stringify(target.value)
-  const findExpr =
-    target.mode === 'testid'
-      ? `(await t.findByTestId(${arg})) || (await t.findById(${arg}))`
-      : `await t.findByText(${arg})`
-  const result = await bridge.send({
-    type: 'evaluate',
-    code: `(async () => {
-      const t = window.__sootsimTest
-      if (!t) return null
-      const n = ${findExpr}
-      if (!n || !n.absolutePosition || !n.layout) return null
-      const resolved =
-        typeof n.nodeId === 'number' && typeof t.resolveTapTarget === 'function'
-          ? await t.resolveTapTarget(n.nodeId)
-          : null
-      const cx =
-        typeof resolved?.cx === 'number'
-          ? resolved.cx
-          : n.absolutePosition.x + (n.layout.width || 0) / 2
-      const cy =
-        typeof resolved?.cy === 'number'
-          ? resolved.cy
-          : n.absolutePosition.y + (n.layout.height || 0) / 2
-      return {
-        x: cx,
-        y: cy,
-        id: n.id ?? null,
-        testID: n.testID ?? null,
-        text: ${JSON.stringify(target.mode === 'text')} ? ${arg} : (n.text ?? n.accessibilityLabel ?? null),
-        type: n.type ?? null,
-      }
-    })()`,
+}
+
+export async function resolveTargetCoords(
+  bridge: WsBridge,
+  target: { mode: 'testid' | 'text'; value: string },
+): Promise<ResolvedTargetCoords | null> {
+  const result: unknown = await bridge.send({
+    type: 'resolve',
+    selector:
+      target.mode === 'testid' ? { testID: target.value } : { text: target.value },
   })
-  return (result ?? null) as {
-    x: number
-    y: number
-    id?: string | null
-    testID?: string | null
-    text?: string | null
-    type?: string | null
-  } | null
+  if (result === null) return null
+  if (typeof result !== 'object') throw new Error('resolve returned an invalid result')
+  const match = Reflect.get(result, 'match')
+  const resolvedTarget = Reflect.get(result, 'target')
+  const semanticNodes = [match, resolvedTarget]
+  const point = Reflect.get(result, 'point')
+  const x =
+    point !== null && typeof point === 'object' ? Reflect.get(point, 'x') : undefined
+  const y =
+    point !== null && typeof point === 'object' ? Reflect.get(point, 'y') : undefined
+  if (
+    !isSimSemanticTree(semanticNodes) ||
+    typeof x !== 'number' ||
+    !Number.isFinite(x) ||
+    typeof y !== 'number' ||
+    !Number.isFinite(y)
+  ) {
+    throw new Error('resolve returned an invalid result')
+  }
+  const semanticMatch = semanticNodes[0]
+  if (!semanticMatch) throw new Error('resolve returned an invalid result')
+  return {
+    x,
+    y,
+    testID: semanticMatch.testID ?? null,
+    text:
+      semanticMatch.text ?? (target.mode === 'text' ? target.value : semanticMatch.label),
+    type: semanticMatch.type,
+  }
 }

package/cli/commands/inspect/shared.ts

@@ -11,14 +11,7 @@ import {
   type ParsedBridgeCliArgs,
   type WsBridge,
 } from '../../ws-bridge'
-import {
-  getShellState,
-  isShellCommandUnavailable,
-  readyProbeHasContent,
-  READY_NODE_STABLE_MS,
-  WAIT_READY_PROBE,
-  type ReadyProbe,
-} from './core'
+import { getShellState, inspectWaitReady, isShellCommandUnavailable } from './core'
 import type { SootSimScreenTransitionWaitResult } from '@sootsim/globals'
 
 // shell-state helpers live in the transport-agnostic kernel module so the CLI
@@ -230,124 +223,36 @@ export interface ReloadReadyResult {
   errors: number
 }
 
-// drives the post-reload wait with short bridge-side probes. used by
-// `sootsim reload` (both the in-place hot-remount and the full-page reload
-// paths). primary ready signal is window.__sootsimExternalAppReady, set by
-// shell-events-bridge on the `sootsim:externalAppReady` event, plus visible
-// inspectable content (or a larger non-placeholder tree) and a brief stable
-// node count. a single long in-page evaluate can hold a stale shell-owned tree
-// snapshot until it returns; separate probes let the host process pending
-// shellTreeUpdate traffic between reads. bails early if the console picks up
-// errors after a grace period with the flag still unset — fatal bundle/eval
-// failures pile up errors fast and never emit ready, so waiting the full
-// budget just wastes wall time. falls back to the same content gate on timeout
-// so apps that never wire up the shell-events bridge don't hard-fail reload.
+// post-reload readiness is the same engine-owned condition as `rnx wait ready`.
+// keeping reload on that primitive prevents another polling implementation
+// from drifting on loading text, live frames, or tree stability.
 export async function pollForReloadReady(
   bridge: WsBridge,
-  opts: {
-    timeoutMs?: number
-    errorGraceMs?: number
-    pollIntervalMs?: number
-  } = {},
+  opts: { timeoutMs?: number } = {},
 ): Promise<ReloadReadyResult> {
   const timeoutMs = opts.timeoutMs ?? 10000
-  const errorGraceMs = opts.errorGraceMs ?? 3000
-  const pollIntervalMs = opts.pollIntervalMs ?? 200
-  const start = Date.now()
-  const deadline = start + timeoutMs
-  let lastNodes = -1
-  let nodeStableSince = start
-  let lastExternalReady: unknown = null
-  let lastExternalErrored = false
-  let last: ReloadReadyResult = {
-    ready: false,
-    source: 'timeout',
-    elapsedMs: 0,
-    nodes: 0,
-    targets: 0,
-    liveFrameActive: false,
-    liveFrameChannels: 0,
-    liveFramePublishes: 0,
-    flag: undefined,
-    loadingText: '',
-    externalReady: null,
-    externalStatus: '',
-    externalError: '',
-    errors: 0,
-  }
-
-  while (Date.now() < deadline) {
-    try {
-      const probe = (await bridge.send({
-        type: 'evaluate',
-        code: WAIT_READY_PROBE,
-      })) as Partial<ReadyProbe> | null
-      const elapsedMs = Date.now() - start
-      const nodes = Number(probe?.nodes) || 0
-      const targets = Number(probe?.targets) || 0
-      const liveFrameActive = probe?.liveFrameActive === true
-      const liveFrameChannels = Number(probe?.liveFrameChannels) || 0
-      const liveFramePublishes = Number(probe?.liveFramePublishes) || 0
-      const errors = Number(probe?.errors) || 0
-      const readyFlag = probe?.flag === true
-      const externalReady = probe?.externalReady
-      const loadingText =
-        typeof probe?.loadingText === 'string' ? probe.loadingText.trim() : ''
-      const externalStatus =
-        typeof probe?.externalStatus === 'string' ? probe.externalStatus.trim() : ''
-      const externalError =
-        typeof probe?.externalError === 'string' ? probe.externalError.trim() : ''
-      const externalErrored =
-        typeof probe?.externalError === 'string' && externalError.length > 0
-      lastExternalReady = externalReady
-      lastExternalErrored = externalErrored
-      if (nodes !== lastNodes) {
-        lastNodes = nodes
-        nodeStableSince = elapsedMs
-      }
-      last = {
-        ready: false,
-        source: 'timeout',
-        elapsedMs,
-        nodes,
-        targets,
-        liveFrameActive,
-        liveFrameChannels,
-        liveFramePublishes,
-        flag: probe?.flag,
-        loadingText,
-        externalReady: typeof externalReady === 'boolean' ? externalReady : null,
-        externalStatus,
-        externalError,
-        errors,
-      }
-      if (
-        readyFlag &&
-        externalReady !== false &&
-        !externalErrored &&
-        !loadingText &&
-        readyProbeHasContent({ liveFrameActive, nodes, targets })
-      ) {
-        if (elapsedMs - nodeStableSince >= READY_NODE_STABLE_MS) {
-          return { ...last, ready: true, source: 'flag' }
-        }
-      }
-      if (elapsedMs >= errorGraceMs && errors > 0 && !readyFlag) {
-        return { ...last, ready: false, source: 'error-bail' }
-      }
-    } catch {
-      // transient bridge disconnect during full-page reload — keep polling.
-    }
-    await sleep(pollIntervalMs)
-  }
-
-  if (
-    lastExternalReady !== false &&
-    !lastExternalErrored &&
-    !last.loadingText &&
-    readyProbeHasContent(last)
-  ) {
-    return { ...last, ready: true, source: 'nodes-fallback' }
+  const status = await inspectWaitReady(bridge, timeoutMs)
+  const source = status.ready
+    ? status.flag === true
+      ? 'flag'
+      : 'nodes-fallback'
+    : status.errors > 0 && status.flag !== true
+      ? 'error-bail'
+      : 'timeout'
+  return {
+    ready: status.ready,
+    source,
+    elapsedMs: status.elapsedMs,
+    nodes: status.nodes,
+    targets: status.targets,
+    liveFrameActive: status.liveFrameActive,
+    liveFrameChannels: status.liveFrameChannels,
+    liveFramePublishes: status.liveFramePublishes,
+    flag: status.flag,
+    loadingText: status.loadingText,
+    externalReady: status.externalReady,
+    externalStatus: status.externalStatus,
+    externalError: status.externalError,
+    errors: status.errors,
   }
-  return { ...last, ready: false, source: 'timeout', elapsedMs: Date.now() - start }
 }

package/cli/commands/inspect/tree.ts

@@ -1,9 +1,6 @@
-// `sootsim get tree` — raw node tree dump, default depth 5.
-//
-// goes through the merged test bridge (shell + tenant) rather than the raw
-// tree message, which only walks the tenant root.
+// `sootsim get tree` — pruned structured semantic tree, default depth 5.
 
-import { inspectTree } from './core'
+import { formatSemanticTree, inspectTree, isSimSemanticTree } from './core'
 import { printJson, wantsJson } from './shared'
 import type { WsBridge } from '../../ws-bridge'
 
@@ -13,20 +10,14 @@ export async function runTreeSubcommand(opts: {
   positional: string[]
 }): Promise<void> {
   const { bridge, args, positional } = opts
-  // --boxes: structured nested rects ({ type, testID?, text?, x, y, w, h,
-  // bg?, fg?, br?, children? }) in absolute device coords — for layout
-  // tooling that needs real geometry, not the rendered text dump. deeper
-  // default depth because geometry consumers want the whole tree.
+  // --boxes keeps the deeper default expected by geometry consumers. the
+  // semantic tree is structured in both modes.
   const boxes = args.includes('--boxes')
   const depth = positional[1] ? Number(positional[1]) : boxes ? 50 : 5
-  const { tree } = await inspectTree(
-    bridge,
-    depth,
-    boxes ? { format: 'boxes' } : undefined,
-  )
+  const { tree } = await inspectTree(bridge, depth)
   if (wantsJson(args)) {
     printJson({ depth, tree: tree ?? null })
     return
   }
-  console.log(typeof tree === 'string' ? tree : JSON.stringify(tree, null, 2))
+  console.log(isSimSemanticTree(tree) ? formatSemanticTree(tree) : '')
 }

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

@@ -6,8 +6,8 @@ import type { WsBridge } from '../../ws-bridge'
 // inspectable content. the persistent window flag
 // `__sootsimExternalAppReady` is necessary but not sufficient: shell-owned
 // canvas can expose a stable launch/loading tree before the app content lands.
-// the polling loop lives in inspect/core.ts (`inspectWaitReady`) so the CLI
-// and the agent share it; this handler just parses flags and reports.
+// the engine owns the polling loop; this handler sends one request, then
+// reports the typed result.
 export async function runWaitReadySubcommand(opts: {
   bridge: WsBridge
   args: string[]

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

@@ -2,8 +2,8 @@ import { inspectWaitSelector } from './core'
 import type { WsBridge } from '../../ws-bridge'
 
 // blocks until a node with the given testID is present and laid out, or — with
-// `--gone` — until it is absent. the polling logic lives in inspect/core.ts
-// (`inspectWaitSelector`); this handler parses args and reports.
+// `--gone` — until it is absent. the engine owns the polling loop and this
+// handler sends one request, then reports.
 export async function runWaitSelectorSubcommand(opts: {
   bridge: WsBridge
   args: string[]
@@ -38,12 +38,8 @@ export async function runWaitSelectorSubcommand(opts: {
   }
 
   if (found && node) {
-    const loc = node.absolutePosition
-      ? `@(${Math.round(node.absolutePosition.x)},${Math.round(node.absolutePosition.y)})`
-      : ''
-    const size = node.layout
-      ? `${Math.round(node.layout.width)}x${Math.round(node.layout.height)}`
-      : '?x?'
+    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(

package/cli/commands/inspect.ts

@@ -45,6 +45,7 @@ import {
   filterLogEntries,
   inspectAccessibilityTree,
   inspectErrors,
+  inspectFind,
   inspectLogs,
   inspectRequests,
   inspectWarnings,
@@ -1060,8 +1061,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
       // nothing). value-taking describe flags live in stripValueFlags below.
       '--compact',
       '--no-xy',
-      '--no-clipped',
-      '--include-occluded',
     ],
     stripValueFlags: [
       '--output',
@@ -1749,12 +1748,28 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           await runGetLayoutSubcommand({ bridge, args: effectiveArgs })
           break
         }
-        // use async for worker mode bridge
-        const layout = await bridge.send({
-          type: 'evaluate',
-          code: `(async () => await window.__sootsimTest.getLayout(${JSON.stringify(id)}))()`,
-        })
-        console.log(JSON.stringify(layout, null, 2))
+        const found = await inspectFind(bridge, { testId: id })
+        const node = found?.result
+        if (node === null || typeof node !== 'object' || Array.isArray(node)) {
+          console.log('null')
+          break
+        }
+        const absolute = Reflect.get(node, 'absolutePosition')
+        const size = Reflect.get(node, 'layout')
+        console.log(
+          JSON.stringify(
+            absolute && size
+              ? {
+                  x: Reflect.get(absolute, 'x'),
+                  y: Reflect.get(absolute, 'y'),
+                  width: Reflect.get(size, 'width'),
+                  height: Reflect.get(size, 'height'),
+                }
+              : null,
+            null,
+            2,
+          ),
+        )
         break
       }
 
@@ -1906,14 +1921,12 @@ export async function runInspect(args: string[], opts: InspectOptions) {
                 cx: resolved.x,
                 cy: resolved.y,
                 match: {
-                  id: target.mode === 'testid' ? target.value : (resolved.id ?? null),
                   testID:
                     target.mode === 'testid' ? target.value : (resolved.testID ?? null),
                   text: target.mode === 'text' ? target.value : (resolved.text ?? null),
                   type: resolved.type ?? null,
                 },
                 target: {
-                  id: resolved.id ?? null,
                   testID: resolved.testID ?? null,
                   text: resolved.text ?? null,
                   type: resolved.type ?? null,
@@ -2684,7 +2697,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         let y = Number(positional[2])
         const target = readTargetFlag(args, positional)
         let resolvedTarget: {
-          id?: string | null
           testID?: string | null
           text?: string | null
           type?: string | null
@@ -2701,7 +2713,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           x = resolved.x
           y = resolved.y
           resolvedTarget = {
-            id: resolved.id ?? null,
             testID: resolved.testID ?? null,
             text: resolved.text ?? null,
             type: resolved.type ?? null,
@@ -3382,7 +3393,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         // failures surface as console errors that pile up fast — bail early
         // in that case instead of waiting the full budget.
         const READY_TIMEOUT_MS = 10000
-        const ERROR_GRACE_MS = 3000
         let issuedReload = false
         let inPlaceReload = false
         try {
@@ -3432,7 +3442,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         if (inPlaceReload) {
           readyResult = await pollForReloadReady(bridge, {
             timeoutMs: READY_TIMEOUT_MS,
-            errorGraceMs: ERROR_GRACE_MS,
           })
         } else {
           // full page reload — wait for a fresh bridge before polling for ready.
@@ -3452,7 +3461,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
             finalBridge = reconnected
             readyResult = await pollForReloadReady(reconnected, {
               timeoutMs: PAGE_RELOAD_TIMEOUT_MS,
-              errorGraceMs: ERROR_GRACE_MS,
             })
           } else {
             console.log(
@@ -3517,7 +3525,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
 
       case 'storage-clear': {
         const READY_TIMEOUT_MS = 10000
-        const ERROR_GRACE_MS = 3000
         await clearConsole(bridge)
         const cleared = await bridge.send({
           type: 'evaluate',
@@ -3541,7 +3548,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
 
         const readyResult = await pollForReloadReady(bridge, {
           timeoutMs: READY_TIMEOUT_MS,
-          errorGraceMs: ERROR_GRACE_MS,
         })
 
         if (wantsJson(effectiveArgs)) {