rnxsim 0.1.366 → 0.1.368

package/skills/contrast/SKILL.md

@@ -42,6 +42,9 @@ automation, inspecting the render tree, and managing sims.
 | `rnx debug` | drive __sootsimDebug: channels, snapshots, and inspectors |
 | `rnx what-happened` | show recent semantic events: toasts, keyboards, screens, alerts, fetches, errors |
 | `rnx timeline` | control the semantic event timeline (enable opt-in kinds, clear, dump) |
+| `rnx box` | start a local box and enter its shell |
+| `rnx ios` | start an iOS simulator |
+| `rnx android` | start an Android simulator |
 | `rnx open` | load a target into the current sim or open a new one |
 | `rnx list` | list connected sims or available launch drivers |
 | `rnx use` | select a connected sim |

package/skills/rnx-debug/SKILL.md

@@ -147,6 +147,14 @@ rnx debug diff before after          # structural diff: what changed?
 rnx what-happened                    # timeline events during the repro
 ```
 
+when the repro needs several closely timed inputs, replace the individual
+write calls with one inline batch so WebSocket scheduling cannot change the
+gesture:
+
+```sh
+rnx do touch down 200 600 --then sleep 0.03 --then touch move 200 250 --then touch up 200 250
+```
+
 for nested scroll ownership or momentum transfer, compare the shell's resolved
 gesture chain with the published scroll registry:
 

package/skills/rnx-test/SKILL.md

@@ -21,6 +21,7 @@ the official Vite or Metro plugin, and test-only work must not open that window.
 - have an existing `.maestro/` directory? → [Maestro](#branch--maestro)
 - have existing Detox specs? → [detox drop-in](#branch--detox-drop-in)
 - writing tests fresh, want plain-language generation, or want live authoring? → [Maestro](#branch--maestro)
+- need one short, timing-sensitive sequence from the shell? → [inline chains](#one-off-inline-chains)
 
 Do not invent a third runner for how a Maestro flow was authored.
 
@@ -43,6 +44,8 @@ Do not invent a third runner for how a Maestro flow was authored.
 - **don't run a 40-step "smoke everything" flow.** when it fails, you
   can't tell what regressed. split into `login.yaml`, `compose.yaml`,
   `settings.yaml`, chain with `runFlow`.
+- **inside an `rnx do` chain, use `sleep` only for gesture timing.** after the
+  chain, use `rnx wait` for app state so automation advances on a real condition.
 
 ## you're done when
 
@@ -52,6 +55,24 @@ Do not invent a third runner for how a Maestro flow was authored.
 - the green run took noticeably less wall-clock than the previous
   baseline (a suite that grows slower without growing wider is a smell)
 
+## one-off inline chains
+
+repeat `--then` before each additional `do` action to run one ordered engine
+batch. use a chain for a short repro, form fill, or timing-sensitive gesture
+that does not belong in a saved test:
+
+```sh
+rnx do tap email --then type user@example.com --then tap submit
+rnx wait selector dashboard
+```
+
+the batch stops on the first failure. add `--json` for per-action results.
+`tap <id>` and `tap-id <id>` are exact; use `tap-text <text>` for visible text.
+punctuation in action data remains data. the exact `--then` token is reserved
+as the action boundary. use Maestro when the sequence should be reviewed,
+reused, or run in CI; an inline chain is not a third test runner and does not
+read flow files.
+
 ## branch — Maestro
 
 Write declarative Maestro YAML. The same command runs existing suites,

package/src/bridge-contract-input.ts

@@ -0,0 +1,359 @@
+// untrusted JSON -> bridge-contract argument. one owner for that conversion, so
+// every transport in front of a sim (the RNX Cloud sim service's HTTP and
+// WebSocket routes) validates its request bodies here rather than growing a
+// second reader for the same shapes.
+
+import type {
+  ResetOptions,
+  SemanticWaitOptions,
+  SimSemanticQuery,
+  SimSemanticResolveSelector,
+  SimSemanticSelector,
+  SimStateOptions,
+} from './bridge-contract'
+import type { SimPerformStep, SimScreenshotOptions } from './sim-client'
+
+/** the caller sent a value this bridge argument cannot be read from. */
+export class BridgeInputError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'BridgeInputError'
+  }
+}
+
+export const SEMANTIC_WAIT_MAX_TIMEOUT_MS = 30_000
+
+function validationFailure(path: string, expectation: string): never {
+  throw new BridgeInputError(`${path} ${expectation}`)
+}
+
+function isRecordValue(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function recordValue(value: unknown, path: string): Record<string, unknown> {
+  if (!isRecordValue(value)) {
+    validationFailure(path, 'must be an object')
+  }
+  return value
+}
+
+function stringValue(value: unknown, path: string): string {
+  if (typeof value !== 'string') validationFailure(path, 'must be a string')
+  return value
+}
+
+function numberValue(value: unknown, path: string): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    validationFailure(path, 'must be a finite number')
+  }
+  return value
+}
+
+function booleanValue(value: unknown, path: string): boolean {
+  if (typeof value !== 'boolean') validationFailure(path, 'must be a boolean')
+  return value
+}
+
+function optionalNumber(
+  record: Record<string, unknown>,
+  key: string,
+  path: string,
+): number | undefined {
+  return record[key] === undefined
+    ? undefined
+    : numberValue(record[key], `${path}.${key}`)
+}
+
+function optionalBoolean(
+  record: Record<string, unknown>,
+  key: string,
+  path: string,
+): boolean | undefined {
+  return record[key] === undefined
+    ? undefined
+    : booleanValue(record[key], `${path}.${key}`)
+}
+
+function semanticWaitTimeout(
+  record: Record<string, unknown>,
+  path: string,
+): number | undefined {
+  const timeoutMs = optionalNumber(record, 'timeoutMs', path)
+  if (timeoutMs !== undefined && timeoutMs > SEMANTIC_WAIT_MAX_TIMEOUT_MS) {
+    validationFailure(
+      `${path}.timeoutMs`,
+      `must be at most ${SEMANTIC_WAIT_MAX_TIMEOUT_MS}`,
+    )
+  }
+  return timeoutMs
+}
+
+export function parsePerformStep(value: unknown, index: number): SimPerformStep {
+  const path = `perform.steps[${index}]`
+  const step = recordValue(value, path)
+  const type = stringValue(step.type, `${path}.type`)
+  switch (type) {
+    case 'touchDown':
+    case 'touchMove':
+    case 'touchUp': {
+      const pointerId = optionalNumber(step, 'pointerId', path)
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...(pointerId === undefined ? {} : { pointerId }),
+      }
+    }
+    case 'touchCancel': {
+      const pointerId = optionalNumber(step, 'pointerId', path)
+      return { type, ...(pointerId === undefined ? {} : { pointerId }) }
+    }
+    case 'tap':
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+      }
+    case 'tapId':
+      return { type, id: stringValue(step.id, `${path}.id`) }
+    case 'tapText':
+      return { type, text: stringValue(step.text, `${path}.text`) }
+    case 'doubleTap': {
+      const gapMs = optionalNumber(step, 'gapMs', path)
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...(gapMs === undefined ? {} : { gapMs }),
+      }
+    }
+    case 'longPress': {
+      const durationMs = optionalNumber(step, 'durationMs', path)
+      return {
+        type,
+        x: numberValue(step.x, `${path}.x`),
+        y: numberValue(step.y, `${path}.y`),
+        ...(durationMs === undefined ? {} : { durationMs }),
+      }
+    }
+    case 'drag': {
+      const steps = optionalNumber(step, 'steps', path)
+      const stepMs = optionalNumber(step, 'stepMs', path)
+      return {
+        type,
+        fromX: numberValue(step.fromX, `${path}.fromX`),
+        fromY: numberValue(step.fromY, `${path}.fromY`),
+        toX: numberValue(step.toX, `${path}.toX`),
+        toY: numberValue(step.toY, `${path}.toY`),
+        ...(steps === undefined ? {} : { steps }),
+        ...(stepMs === undefined ? {} : { stepMs }),
+      }
+    }
+    case 'pinch': {
+      const steps = optionalNumber(step, 'steps', path)
+      const stepMs = optionalNumber(step, 'stepMs', path)
+      return {
+        type,
+        fromX1: numberValue(step.fromX1, `${path}.fromX1`),
+        fromY1: numberValue(step.fromY1, `${path}.fromY1`),
+        fromX2: numberValue(step.fromX2, `${path}.fromX2`),
+        fromY2: numberValue(step.fromY2, `${path}.fromY2`),
+        toX1: numberValue(step.toX1, `${path}.toX1`),
+        toY1: numberValue(step.toY1, `${path}.toY1`),
+        toX2: numberValue(step.toX2, `${path}.toX2`),
+        toY2: numberValue(step.toY2, `${path}.toY2`),
+        ...(steps === undefined ? {} : { steps }),
+        ...(stepMs === undefined ? {} : { stepMs }),
+      }
+    }
+    case 'scroll': {
+      const x = optionalNumber(step, 'x', path)
+      const y = optionalNumber(step, 'y', path)
+      const animated = optionalBoolean(step, 'animated', path)
+      return {
+        type,
+        id: stringValue(step.id, `${path}.id`),
+        ...(x === undefined ? {} : { x }),
+        ...(y === undefined ? {} : { y }),
+        ...(animated === undefined ? {} : { animated }),
+      }
+    }
+    case 'type':
+      return { type, text: stringValue(step.text, `${path}.text`) }
+    case 'key':
+      return { type, key: stringValue(step.key, `${path}.key`) }
+    case 'dismissKeyboard':
+      return { type }
+    case 'wait':
+      return { type, ms: numberValue(step.ms, `${path}.ms`) }
+    case 'waitFor': {
+      const timeoutMs = semanticWaitTimeout(step, path)
+      const selector =
+        step.testID === undefined
+          ? { id: stringValue(step.id, `${path}.id`) }
+          : { testID: stringValue(step.testID, `${path}.testID`) }
+      return {
+        type,
+        ...selector,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+      }
+    }
+    default:
+      return validationFailure(`${path}.type`, 'is not a supported perform step')
+  }
+}
+
+export function parseStateOptions(value: unknown): SimStateOptions {
+  const input = recordValue(value, 'state')
+  const route = optionalBoolean(input, 'route', 'state')
+  const errors = optionalBoolean(input, 'errors', 'state')
+  const depth = optionalNumber(input, 'depth', 'state')
+  const errorLimit = optionalNumber(input, 'errorLimit', 'state')
+  const layers =
+    input.layers === undefined ? undefined : stringValue(input.layers, 'state.layers')
+  if (
+    layers !== undefined &&
+    layers !== 'full' &&
+    layers !== 'tenant' &&
+    layers !== 'shell'
+  ) {
+    return validationFailure('state.layers', 'must be full, tenant, or shell')
+  }
+  return {
+    screenshot: optionalBoolean(input, 'screenshot', 'state') ?? true,
+    tree: optionalBoolean(input, 'tree', 'state') ?? true,
+    ...(route === undefined ? {} : { route }),
+    ...(errors === undefined ? {} : { errors }),
+    ...(depth === undefined ? {} : { depth }),
+    ...(layers === undefined ? {} : { layers }),
+    ...(errorLimit === undefined ? {} : { errorLimit }),
+  }
+}
+
+function parseSemanticSelector(value: unknown, path: string): SimSemanticSelector {
+  const selector = recordValue(value, path)
+  if (selector.testID !== undefined) {
+    return { testID: stringValue(selector.testID, `${path}.testID`) }
+  }
+  if (selector.text !== undefined) {
+    return { text: stringValue(selector.text, `${path}.text`) }
+  }
+  if (selector.role !== undefined) {
+    return { role: stringValue(selector.role, `${path}.role`) }
+  }
+  if (selector.type !== undefined) {
+    return { type: stringValue(selector.type, `${path}.type`) }
+  }
+  if (selector.pressable !== undefined) {
+    if (booleanValue(selector.pressable, `${path}.pressable`) !== true) {
+      return validationFailure(`${path}.pressable`, 'must be true')
+    }
+    return { pressable: true }
+  }
+  if (selector.visible !== undefined) {
+    if (booleanValue(selector.visible, `${path}.visible`) !== true) {
+      return validationFailure(`${path}.visible`, 'must be true')
+    }
+    return { visible: true }
+  }
+  return validationFailure(
+    path,
+    'must select testID, text, role, type, pressable, or visible',
+  )
+}
+
+export function parseSemanticQuery(value: unknown): SimSemanticQuery {
+  const query = recordValue(value, 'query')
+  const kind = stringValue(query.kind, 'query.kind')
+  if (kind === 'count') return { kind }
+  if (kind === 'tree') {
+    const depth = optionalNumber(query, 'depth', 'query')
+    return { kind, ...(depth === undefined ? {} : { depth }) }
+  }
+  if (kind === 'find') {
+    return { kind, selector: parseSemanticSelector(query.selector, 'query.selector') }
+  }
+  return validationFailure('query.kind', 'must be tree, find, or count')
+}
+
+export function parseSemanticResolveSelector(value: unknown): SimSemanticResolveSelector {
+  const selector = recordValue(value, 'selector')
+  if (selector.testID !== undefined) {
+    return { testID: stringValue(selector.testID, 'selector.testID') }
+  }
+  if (selector.text !== undefined) {
+    return { text: stringValue(selector.text, 'selector.text') }
+  }
+  return validationFailure('selector', 'must select testID or text')
+}
+
+export function parseSemanticWaitOptions(value: unknown): SemanticWaitOptions {
+  const input = recordValue(value, 'waitFor')
+  const condition = recordValue(input.condition, 'waitFor.condition')
+  const type = stringValue(condition.type, 'waitFor.condition.type')
+  const timeoutMs = semanticWaitTimeout(input, 'waitFor')
+  if (type === 'ready') {
+    return {
+      condition: { type },
+      ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    }
+  }
+  if (type !== 'present' && type !== 'absent') {
+    return validationFailure(
+      'waitFor.condition.type',
+      'must be ready, present, or absent',
+    )
+  }
+  return {
+    condition: {
+      type,
+      testID: stringValue(condition.testID, 'waitFor.condition.testID'),
+    },
+    ...(timeoutMs === undefined ? {} : { timeoutMs }),
+  }
+}
+
+export function parseResetOptions(value: unknown): ResetOptions {
+  const input = recordValue(value, 'reset')
+  const strategy =
+    input.strategy === undefined ? 'data' : stringValue(input.strategy, 'reset.strategy')
+  if (strategy !== 'data' && strategy !== 'full') {
+    return validationFailure('reset.strategy', 'must be data or full')
+  }
+  return {
+    strategy,
+    relaunch: optionalBoolean(input, 'relaunch', 'reset') ?? true,
+  }
+}
+
+export function parseScreenshotOptions(value: unknown): SimScreenshotOptions {
+  const input = recordValue(value, 'screenshot')
+  const layers =
+    input.layers === undefined
+      ? undefined
+      : stringValue(input.layers, 'screenshot.layers')
+  if (
+    layers !== undefined &&
+    layers !== 'full' &&
+    layers !== 'tenant' &&
+    layers !== 'shell'
+  ) {
+    return validationFailure('screenshot.layers', 'must be full, tenant, or shell')
+  }
+  const crop =
+    input.crop === undefined ? undefined : recordValue(input.crop, 'screenshot.crop')
+  return {
+    ...(layers === undefined ? {} : { layers }),
+    ...(crop === undefined
+      ? {}
+      : {
+          crop: {
+            x: numberValue(crop.x, 'screenshot.crop.x'),
+            y: numberValue(crop.y, 'screenshot.crop.y'),
+            w: numberValue(crop.w, 'screenshot.crop.w'),
+            h: numberValue(crop.h, 'screenshot.crop.h'),
+          },
+        }),
+  }
+}

package/src/bridge-contract.ts

@@ -25,13 +25,18 @@ export type BridgeCommandType =
   | 'close'
   | 'flowStatus'
   | 'perform'
+  | 'waitFor'
   | 'state'
+  | 'query'
+  | 'resolve'
   | 'reset'
   | 'camera'
 
 export interface WsCommand {
   id: string | number
   type: BridgeCommandType
+  // local daemon routing; cloud transport strips it before execution.
+  simId?: string
   // flowStatus — live flow-runner progress payload (see flow-run-store)
   status?: Record<string, unknown>
   code?: string
@@ -57,8 +62,13 @@ export interface WsCommand {
   // perform — ordered batch executed inside the page, no round trips
   steps?: PerformStep[]
   performOptions?: PerformOptions
+  // waitFor — one engine-side polling loop and one transport round trip
+  waitForOptions?: SemanticWaitOptions
   // state — compound screenshot + tree + route + errors
   stateOptions?: SimStateOptions
+  // query / resolve — structured visible-tree reads and selector geometry
+  query?: SimSemanticQuery
+  selector?: SimSemanticResolveSelector
   // reset — two-tier app state wipe
   resetOptions?: ResetOptions
   // camera — fixture injection into the host camera pipeline
@@ -158,6 +168,67 @@ export interface PerformResult {
   error?: string
 }
 
+// ---------------------------------------------------------------------------
+// waitFor — engine-side semantic condition polling
+// ---------------------------------------------------------------------------
+
+export type SemanticWaitCondition =
+  | { type: 'ready' }
+  | { type: 'present'; testID: string }
+  | { type: 'absent'; testID: string }
+
+export interface SemanticWaitOptions {
+  condition: SemanticWaitCondition
+  timeoutMs?: number
+}
+
+export interface SemanticReadyProbe {
+  flag: unknown
+  at: number
+  nodes: number
+  targets: number
+  liveFrameActive: boolean
+  liveFrameChannels: number
+  liveFramePublishes: number
+  errors: number
+  loadingText: string
+  externalReady: boolean | null
+  externalStatus: string
+  externalError: string
+  suppressedEntryError: string
+}
+
+export const SEMANTIC_READY_CONTENT_NODE_FLOOR = 100
+export const SEMANTIC_READY_NODE_STABLE_MS = 750
+export const SEMANTIC_READY_POLL_MS = 150
+
+export function readyProbeHasContent(
+  probe: Pick<SemanticReadyProbe, 'nodes' | 'targets'> &
+    Partial<Pick<SemanticReadyProbe, 'liveFrameActive'>>,
+): boolean {
+  return (
+    probe.liveFrameActive ||
+    probe.targets > 0 ||
+    probe.nodes >= SEMANTIC_READY_CONTENT_NODE_FLOOR
+  )
+}
+
+export function readyProbeHasTargetContent(
+  probe: Pick<SemanticReadyProbe, 'targets'> &
+    Partial<Pick<SemanticReadyProbe, 'liveFrameActive'>>,
+): boolean {
+  return probe.liveFrameActive || probe.targets > 0
+}
+
+export interface SemanticWaitResult {
+  matched: boolean
+  elapsedMs: number
+  polls: number
+  probe?: SemanticReadyProbe
+  node?: SimSemanticNode
+  error?: string
+}
+
 // ---------------------------------------------------------------------------
 // state — one round-trip situational awareness
 // ---------------------------------------------------------------------------
@@ -178,13 +249,62 @@ export interface SimStateOptions {
 export interface SimStateResult {
   // png data uri, same encoding the `screenshot` command returns
   screenshot?: unknown
-  tree?: unknown
+  tree?: SimSemanticNode[]
   route?: { url?: string; screen?: string | null; stack?: string[] } | null
   recentErrors?: Array<{ level: string; text: string; at?: number }>
   keyboard?: { visible: boolean; mode?: string | null }
   capturedAt: number
 }
 
+// ---------------------------------------------------------------------------
+// semantic tree — pruned visible structure shared by local and cloud runtimes
+// ---------------------------------------------------------------------------
+
+export interface SimSemanticGeometry {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+export interface SimSemanticNode {
+  nodeId: number
+  type: string
+  testID?: string
+  text?: string
+  role?: string
+  label?: string
+  pressable?: true
+  geometry: SimSemanticGeometry
+  children?: SimSemanticNode[]
+}
+
+export type SimSemanticSelector =
+  | { testID: string }
+  | { text: string }
+  | { role: string }
+  | { type: string }
+  | { pressable: true }
+  | { visible: true }
+
+export type SimSemanticQuery =
+  | { kind: 'tree'; depth?: number }
+  | { kind: 'find'; selector: SimSemanticSelector }
+  | { kind: 'count' }
+
+export interface SimSemanticQueryResult {
+  nodes: SimSemanticNode[]
+  total: number
+}
+
+export type SimSemanticResolveSelector = { testID: string } | { text: string }
+
+export interface SimSemanticResolveResult {
+  match: SimSemanticNode
+  target: SimSemanticNode
+  point: { x: number; y: number }
+}
+
 // ---------------------------------------------------------------------------
 // reset — two-tier app state wipe
 // ---------------------------------------------------------------------------

package/src/host/bridge-host.ts

@@ -54,6 +54,7 @@ import {
   isReplacementModuleRequestUrl,
 } from './replacement-module-handler.ts'
 import { handleWebSocketProxyUpgrade } from './websocket-proxy.ts'
+import type { WsCommand } from '../bridge-contract.ts'
 
 const SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY = 'require-corp'
 
@@ -92,17 +93,7 @@ export interface BridgeLockInfo {
   expiresInMs: number
 }
 
-export interface BridgeSimCommand {
-  id: number
-  type: 'evaluate' | 'screenshot' | 'tap' | 'keyboard' | 'tree' | 'focus' | 'close'
-  code?: string
-  x?: number
-  y?: number
-  action?: string
-  text?: string
-  depth?: number
-  simId?: string
-}
+export type BridgeSimCommand = Omit<WsCommand, 'id'> & { id: number }
 
 interface BridgeSimRegistrationMessage {
   type: 'bridge:register'
@@ -173,7 +164,7 @@ interface BridgeCliLease {
 }
 
 // interactive commands change app state and must respect the lease.
-// observational/lifecycle commands (evaluate/tree/screenshot/focus/call/close)
+// observational/lifecycle commands (evaluate/tree/query/resolve/screenshot/focus/call/close)
 // pass through without taking or checking a lease so cleanup never gets stuck
 // behind a stale cli owner.
 // `call` used to acquire a lease too, but most call paths are queries
@@ -2555,6 +2546,10 @@ export class SootSimBridgeHost {
         return msg?.action === 'type' ? 'typed text' : 'used keyboard'
       case 'tree':
         return 'dumped tree'
+      case 'query':
+        return 'queried semantic tree'
+      case 'resolve':
+        return 'resolved semantic selector'
       case 'focus':
         return 'focused sim'
       case 'close':

package/src/index.ts

@@ -27,6 +27,13 @@ export type {
   ResetResult,
   SimStateOptions,
   SimStateResult,
+  SimSemanticGeometry,
+  SimSemanticNode,
+  SimSemanticQuery,
+  SimSemanticQueryResult,
+  SimSemanticResolveResult,
+  SimSemanticResolveSelector,
+  SimSemanticSelector,
 } from './bridge-contract'
 
 export { rnxPlugin } from './vite-plugin-one'

package/src/sim-client.ts

@@ -55,6 +55,9 @@ import type {
   PerformStep,
   ResetOptions,
   ResetResult,
+  SimSemanticNode,
+  SimSemanticResolveResult,
+  SimSemanticResolveSelector,
   SimStateOptions,
   SimStateResult,
 } from './bridge-contract'
@@ -386,12 +389,18 @@ export class SimClient implements WsBridge, InspectBridge {
     return result ? [result as InteractiveNode] : []
   }
 
-  async tree(depth = 5): Promise<unknown> {
+  async tree(depth = 5): Promise<SimSemanticNode[]> {
     const { tree } = await inspectTree(this, depth)
-    return tree
+    return Array.isArray(tree) ? tree : []
   }
 
-  /** compact visible-UI dump with shell + keyboard state, as the CLI prints. */
+  resolve(
+    selector: SimSemanticResolveSelector,
+  ): Promise<SimSemanticResolveResult | null> {
+    return this.send({ type: 'resolve', selector })
+  }
+
+  /** compact visible semantic tree, formatted as the CLI prints it. */
   describe(opts: { filter?: string; verbose?: boolean } = {}): Promise<DescribeResult> {
     return inspectDescribe(this, {
       describe: true,