peachsim 0.1.1620 → 0.1.1635

package/cli/bridge-flow-runner.ts

@@ -22,6 +22,10 @@ import { PERMISSION_KINDS } from './commands/permissions'
 import { saveCurrentSimId } from './current-sim'
 import { parseFlowFile } from './flow-file'
 import { FlowLiveStatusReporter } from './flow-live-status'
+import {
+  accessibilityBounds,
+  sameNativeAccessibilityShape,
+} from './maestro-accessibility'
 import { MaestroJsContext, scriptConditionIsTruthy } from './maestro-js'
 import { ensureCliRecordingEntitlement } from './recording-access'
 import type { PerformResult, PerformStep, ResetResult } from '../src/bridge-contract'
@@ -43,6 +47,23 @@ const DEFAULT_TIMEOUT = 10000
 // how long maestro looks for a required assertion's element, counted from the
 // latest interaction (Orchestra lookupTimeoutMs and adjustedToLatestInteraction)
 const ASSERTION_LOOKUP_MS = 17_000
+// commands Orchestra.executeCommand reports as not mutating the device, so
+// they leave the lookup window running; every other command restarts it. the
+// last four are Peach observations with no device effect.
+const NON_MUTATING_STEPS = [
+  'assertTrue',
+  'assertVisible',
+  'assertNotVisible',
+  'extendedWaitUntil',
+  'takeScreenshot',
+  'setClipboard',
+  'copyTextFrom',
+  'clearKeychain',
+  'waitFor',
+  'wait',
+  'dumpTree',
+  'assertTreeContains',
+] as const satisfies readonly (keyof MaestroStep)[]
 const FLOW_TIMEOUT_SCALE = flowTimeoutScale()
 const scaledTimeout = (ms: number) => Math.round(ms * FLOW_TIMEOUT_SCALE)
 
@@ -235,23 +256,6 @@ function accessibilityTextMatcher(
   )
 }
 
-// maestro reads ios frames as integer edges (AXElement.boundsString).
-function accessibilityBounds(node: PeachAccessibilityNode): {
-  x: number
-  y: number
-  width: number
-  height: number
-} {
-  const left = Math.trunc(node.frame.x)
-  const top = Math.trunc(node.frame.y)
-  return {
-    x: left,
-    y: top,
-    width: Math.trunc(node.frame.x + node.frame.width) - left,
-    height: Math.trunc(node.frame.y + node.frame.height) - top,
-  }
-}
-
 const ACCESSIBILITY_TRAIT_FILTERS: Record<string, AccessibilityNodePredicate> = {
   // IOSDriver sets attributes["text"] on every node, including empty text.
   TEXT: () => true,
@@ -355,7 +359,12 @@ function distinctAccessibilityNodes(
       node.children.length,
     ])
     const bucket = buckets.get(key)
-    if (bucket?.some((other) => sameNativeAccessibilityShape(node, other))) return false
+    if (
+      bucket?.some((other) =>
+        sameNativeAccessibilityShape(node, other, accessibilityBounds),
+      )
+    )
+      return false
     if (bucket) bucket.push(node)
     else buckets.set(key, [node])
     return true
@@ -371,39 +380,6 @@ function accessibilityAnchorSelector(value: unknown): FlowTargetSelector {
   return isSelectorRecord(value) ? value : {}
 }
 
-// upstream Filters.containsChild compares the resolved child TreeNode against
-// a candidate's immediate children by structural equality: the native
-// attribute map, the boolean flags, and the children, recursively. the native
-// hintText attribute is the placeholder (accessibilityHint is not a TreeNode
-// attribute), and engine identity (elementId/nodeId) plus the projection's own
-// metadata (type, role, isAccessibilityElement, state) are not part of that
-// native shape.
-function sameNativeAccessibilityShape(
-  a: PeachAccessibilityNode,
-  b: PeachAccessibilityNode,
-): boolean {
-  if (
-    (a.testID ?? '') !== (b.testID ?? '') ||
-    (a.label ?? '') !== (b.label ?? '') ||
-    (a.placeholder ?? '') !== (b.placeholder ?? '') ||
-    (a.value ?? '') !== (b.value ?? '') ||
-    a.enabled !== b.enabled ||
-    a.selected !== b.selected ||
-    a.checked !== b.checked ||
-    a.clickable !== b.clickable ||
-    (a.hasFocus ?? false) !== (b.hasFocus ?? false) ||
-    JSON.stringify(accessibilityBounds(a)) !== JSON.stringify(accessibilityBounds(b)) ||
-    a.children.length !== b.children.length
-  ) {
-    return false
-  }
-  for (const [index, child] of a.children.entries()) {
-    const other = b.children[index]
-    if (!other || !sameNativeAccessibilityShape(child, other)) return false
-  }
-  return true
-}
-
 // Filters.containsDescendants: every selector must match inside a child
 // subtree; the node itself is excluded. A selector matches a subtree node by
 // the full filter applied to that single node (Filters' `matches`), which for
@@ -490,7 +466,7 @@ function filterAccessibilityNodesIn(
     candidates = child
       ? candidates.filter((node) =>
           node.children.some((candidate) =>
-            sameNativeAccessibilityShape(candidate, child),
+            sameNativeAccessibilityShape(candidate, child, accessibilityBounds),
           ),
         )
       : []
@@ -679,6 +655,14 @@ export interface MaestroStep {
     optional?: boolean
   }
   waitForAnimationToEnd?: boolean | number | { timeout?: number }
+  advanceAnimationClock?:
+    | number
+    | number[]
+    | {
+        steps?: number | number[]
+        ms?: number | number[]
+        fps?: number
+      }
   back?: boolean
   hideKeyboard?: boolean
   launchApp?: any
@@ -1009,6 +993,8 @@ export class SootSimBridgeFlowRunner {
 
   private firstLaunchDone = false
   private appStopped = false
+  private animationClockLocked = false
+  private flowDepth = 0
   private profilingEnabled = false
   private recordingEnabled = false
   private recordingAccessChecked = false
@@ -1901,7 +1887,7 @@ export class SootSimBridgeFlowRunner {
         await this.tap(point.x, point.y, point.target)
         await repeatTaps(tappedAtMs, () => this.tap(point.x, point.y, point.target))
       }
-      await this.settleAfterInput()
+      await this.waitForAppToSettle()
       return
     }
     // auto-wait like real maestro: if the target is not mounted yet, poll
@@ -1955,7 +1941,7 @@ export class SootSimBridgeFlowRunner {
           throw new Error(`tapOn refused: ${JSON.stringify(hit)}`)
         if (hit?.hit === true) {
           await repeatTaps(tappedAtMs, () => this.tap(cx, cy, replayTarget))
-          await this.settleAfterInput()
+          await this.waitForAppToSettle()
           if (!current.isTextInput) return
           // confirm focus landed on THIS text input; retry the tap if a
           // previous field still owns focus.
@@ -1977,7 +1963,7 @@ export class SootSimBridgeFlowRunner {
           )
         : null
     if (direct?.ok) {
-      await this.settleAfterInput()
+      await this.waitForAppToSettle()
       return
     }
     throw new Error(`tapOn: element not found: ${JSON.stringify(opts)}`)
@@ -1991,12 +1977,12 @@ export class SootSimBridgeFlowRunner {
     if (result?.ok === false || result?.value === false) {
       throw new Error(`longPressOn: long press missed: ${JSON.stringify(opts)}`)
     }
-    await this.settleAfterInput()
+    await this.waitForAppToSettle()
   }
 
   async tapAtCoords(x: number, y: number) {
     await this.tap(x, y)
-    await this.settleAfterInput()
+    await this.waitForAppToSettle()
   }
 
   async doubleTapAtCoords(x: number, y: number, gapMs = 80) {
@@ -2008,7 +1994,7 @@ export class SootSimBridgeFlowRunner {
         `doubleTapAtCoords failed at (${x}, ${y}): ${result?.error ?? 'double tap missed'}`,
       )
     }
-    await this.settleAfterInput()
+    await this.waitForAppToSettle()
   }
 
   async assertVisible(target: string | { id?: string; text?: string }) {
@@ -2189,48 +2175,58 @@ export class SootSimBridgeFlowRunner {
     await sleep(120)
   }
 
+  // maestro's android driver sends Back. its ios driver never presses a key:
+  // while the keyboard shows it swipes from the screen center up 3%, then
+  // left 3%, and the app's own handling of those touches dismisses it, or
+  // presses whatever sits under the center
   async hideKeyboard() {
-    // CLI flows need "dismiss keyboard" to mean "get the focused TextInput
-    // out of the way before the next tap", not just "ask shell chrome to
-    // animate down eventually". If the TextInput stays focused, the next tap
-    // can still be swallowed by keyboard-dismiss policy on ScrollViews.
-    try {
-      await this.callTest<boolean>('blurFocusedTextInput')
-    } catch {
-      // fall through to the shell-level dismiss below; older bridges may not
-      // expose the text-input helper yet.
+    if (this.js.maestro.platform.toLowerCase() === 'android') {
+      await this.back()
+      await sleep(300)
+      await this.waitForAppToSettle()
+      return
     }
+    if (!(await this.isKeyboardVisible())) return
+    const screen = await this.screenBounds()
+    const center = parsePoint('50%,50%', screen)
+    await this.xctestSwipe(center, parsePoint('50%,47%', screen), 50)
+    if (!(await this.isKeyboardVisible())) return
+    await this.xctestSwipe(center, parsePoint('47%,50%', screen), 50)
+    await this.waitForAppToSettle()
+  }
 
-    await this.bridge.send({
-      type: 'keyboard',
-      simId: this.opts.simId,
-      action: 'dismiss',
-    })
+  // the xctest runner's swipe: press, move to the end over its 100ms tap
+  // duration, rest there for the requested duration, then lift, so the
+  // finger leaves at rest rather than flinging
+  private async xctestSwipe(
+    from: { x: number; y: number },
+    to: { x: number; y: number },
+    durationMs: number,
+  ) {
+    const moves = 6
+    const steps: PerformStep[] = [{ type: 'touchDown', x: from.x, y: from.y }]
+    for (let i = 1; i <= moves; i++) {
+      steps.push({ type: 'wait', ms: 100 / moves })
+      steps.push({
+        type: 'touchMove',
+        x: from.x + ((to.x - from.x) * i) / moves,
+        y: from.y + ((to.y - from.y) * i) / moves,
+      })
+    }
+    steps.push({ type: 'wait', ms: durationMs })
+    steps.push({ type: 'touchUp', x: to.x, y: to.y })
+    const result = await this.perform(steps)
+    if (!result?.ok) throw new Error(`swipe failed: ${result?.error ?? 'swipe missed'}`)
+    await this.waitForAppToSettle()
+  }
 
-    const deadline = Date.now() + 3000
-    do {
-      // the host test bridge proxies the tenant, so isTextInputFocused
-      // resolves a promise; reading it unawaited is always truthy.
-      const state = await this.evaluate<{
-        visible: boolean
-        focused: boolean
-      }>(`(async () => {
-        const keyboard =
-          window.__sootsimKeyboard ??
-          window.SootSim?.bridges?.keyboard ??
-          null
-        const test = window.__sootsimTest
-        return {
-          visible: !!keyboard?.isVisible?.(),
-          focused: !!(await test?.isTextInputFocused?.()),
-        }
-      })()`)
-      if (!state?.visible && !state?.focused) {
-        await sleep(80)
-        return
-      }
-      await sleep(80)
-    } while (Date.now() < deadline)
+  private async isKeyboardVisible(): Promise<boolean> {
+    const visible = await this.evaluate<boolean>(`(() => {
+      const keyboard =
+        window.__sootsimKeyboard ?? window.SootSim?.bridges?.keyboard ?? null
+      return !!keyboard?.isVisible?.()
+    })()`)
+    return visible === true
   }
 
   async eraseText(count: number) {
@@ -2549,7 +2545,7 @@ export class SootSimBridgeFlowRunner {
     if (!result?.ok) {
       throw new Error(`drag failed: ${result?.error ?? 'drag missed'}`)
     }
-    await this.settleAfterInput()
+    await this.waitForAppToSettle()
   }
 
   async swipeCoords(start: string, end: string, duration = 400) {
@@ -2660,6 +2656,76 @@ export class SootSimBridgeFlowRunner {
     })
   }
 
+  // step peach's lockstep animation clock by one or more explicit millisecond
+  // deltas and hold the clock parked at the final frame so a subsequent
+  // takeScreenshot or assertion reads that exact presentation phase.
+  async advanceAnimationClock(spec: NonNullable<MaestroStep['advanceAnimationClock']>) {
+    const rawSteps =
+      typeof spec === 'number' || Array.isArray(spec) ? spec : (spec.steps ?? spec.ms)
+    const steps = (Array.isArray(rawSteps) ? rawSteps : [rawSteps]).map((value) =>
+      Number(value),
+    )
+    if (steps.length === 0 || steps.some((ms) => !Number.isFinite(ms) || ms <= 0)) {
+      throw new Error(
+        `advanceAnimationClock requires positive millisecond step(s): ${JSON.stringify(spec)}`,
+      )
+    }
+    const fps =
+      typeof spec === 'object' &&
+      !Array.isArray(spec) &&
+      typeof spec.fps === 'number' &&
+      Number.isFinite(spec.fps) &&
+      spec.fps > 0
+        ? spec.fps
+        : 60
+    const result = await this.evaluate<{
+      ok: boolean
+      error?: string
+      virtualTimestampMs?: number
+      frameIndex?: number
+    }>(
+      `(async () => {
+        const lockstep = window.SootSim?.bridges?.lockstepCapture
+        if (!lockstep || typeof lockstep.begin !== 'function') {
+          return { ok: false, error: 'lockstep capture bridge unavailable' }
+        }
+        let controller = window.__peachFlowAnimationClockController
+        if (!controller) {
+          controller = await lockstep.begin(${JSON.stringify(fps)})
+          window.__peachFlowAnimationClockController = controller
+        }
+        let receipt = controller.initialFrame
+        for (const ms of ${JSON.stringify(steps)}) {
+          receipt = await controller.stepFrame(ms)
+        }
+        return {
+          ok: true,
+          virtualTimestampMs: receipt?.virtualTimestampMs,
+          frameIndex: receipt?.frameIndex,
+        }
+      })()`,
+      60_000,
+    )
+    if (!result?.ok) {
+      throw new Error(`advanceAnimationClock failed: ${result?.error ?? 'unknown error'}`)
+    }
+    this.animationClockLocked = true
+  }
+
+  private async releaseAnimationClock() {
+    if (!this.animationClockLocked) return
+    this.animationClockLocked = false
+    await this.evaluate(`(() => {
+      const controller = window.__peachFlowAnimationClockController
+      window.__peachFlowAnimationClockController = null
+      if (controller && typeof controller.end === 'function') {
+        controller.end()
+        return
+      }
+      window.SootSim?.bridges?.lockstepCapture?.end?.()
+    })()`).catch(() => {})
+  }
+
   async back() {
     const dispatched = await this.bridge.send({
       type: 'call',
@@ -2709,8 +2775,15 @@ export class SootSimBridgeFlowRunner {
               : { x: centerX, y: screen.height * 0.1 }
       const element = await this.findElement(target)
       if (element) {
-        const { x, y } = element.absolutePosition
-        const { width, height } = element.layout
+        // maestro computes visibility from integer edges, as it does selection.
+        const { x, y, width, height } = accessibilityBounds({
+          frame: {
+            x: element.absolutePosition.x,
+            y: element.absolutePosition.y,
+            width: element.layout.width,
+            height: element.layout.height,
+          },
+        })
         const shownX = Math.max(0, Math.min(x + width, screen.width) - Math.max(x, 0))
         const shownY = Math.max(0, Math.min(y + height, screen.height) - Math.max(y, 0))
         const share = width * height > 0 ? (shownX * shownY) / (width * height) : 0
@@ -2836,6 +2909,12 @@ export class SootSimBridgeFlowRunner {
     const wantsClear = !!(opts && typeof opts === 'object' && opts.clearState)
     const wantsResetRuntime = readBooleanKey(opts, 'resetRuntime')
     const wantsForeground = isObjectRecord(opts) && opts.stopApp === false
+    // maestro's launchApp clears the keychain, then app state, then sets
+    // permissions and launches
+    if (readBooleanKey(opts, 'clearKeychain')) {
+      if (!this.firstLaunchDone && !this.appStopped) await this.waitForTree(120000)
+      await this.clearKeychain()
+    }
     await this.setLaunchPermissions(isObjectRecord(opts) ? opts.permissions : undefined)
 
     if (!this.firstLaunchDone) {
@@ -2926,9 +3005,7 @@ export class SootSimBridgeFlowRunner {
 
   private async setLaunchPermissions(permissions: unknown) {
     const statuses = maestroLaunchPermissions(permissions)
-    const state = await getShellState(this.bridge)
-    const appId = readStringKey(state, 'activeApp') || readRecentShellAppId(state)
-    if (!appId) throw new Error('launchApp: no simulator app to set permissions for')
+    const appId = await this.callTest<string>('permissionGuestAppId')
     for (const [kind, status] of statuses) {
       await this.callTest('permissionSetAppPermission', appId, kind, {
         status,
@@ -2936,14 +3013,8 @@ export class SootSimBridgeFlowRunner {
     }
   }
 
-  // maestro waits around taps for the screen to stop changing, up to
-  // its ios driver's 3 s settle budget, comparing screenshots, so an action
-  // still in flight (a submit spinner, a sheet closing) finishes before the
-  // next command resolves its target. compare consecutive screen pixels,
-  // rather than requiring frame publications to stop for half a second:
-  // a focused input keeps repainting its native blinking caret.
-  // a screen that never stops proceeds when the budget runs out, as there,
-  // and names what kept it moving: every such step pays the whole budget.
+  // ios checks pixels for three seconds, then compares native hierarchies.
+  // the observer overlaps those reads to keep this command's existing budget.
   private async waitForAppToSettle() {
     try {
       const result = await waitForSootsimIdle({
@@ -2951,7 +3022,7 @@ export class SootSimBridgeFlowRunner {
         simId: this.opts.simId,
         maxMs: 3000,
         pollMs: 32,
-        strict: true,
+        maestro: true,
         paintStill: true,
       })
       if (!result.settled) {
@@ -2968,11 +3039,6 @@ export class SootSimBridgeFlowRunner {
     }
   }
 
-  private async settleAfterInput() {
-    await this.waitForAppToSettle()
-    this.lastInteractionAt = Date.now()
-  }
-
   private async waitForVisualSettle() {
     const result = await waitForSootsimIdle({
       bridge: this.bridge,
@@ -2980,19 +3046,10 @@ export class SootSimBridgeFlowRunner {
       maxMs: 10_000,
       pollMs: 32,
       stablePolls: 3,
-      strict: true,
+      maestro: true,
       paintStill: true,
     })
     if (!result.settled) {
-      // an app loop that never ends (a pulsing status dot) leaves only the
-      // pixels moving. maestro on ios captures that frame and continues, so
-      // do the same; any other blocker is real unfinished work and still fails.
-      if (result.blockedBy.startsWith('screen pixels still changing over ')) {
-        console.warn(
-          `  [flow]   screen never became still in ${result.elapsed}ms; capturing as maestro does`,
-        )
-        return
-      }
       throw new Error(
         `visual state did not settle within ${result.elapsed}ms (${result.blockedBy})`,
       )
@@ -3373,8 +3430,6 @@ export class SootSimBridgeFlowRunner {
           step.extendedWaitUntil ||
           step.waitFor ||
           step.scrollUntilVisible ||
-          // deep links own the same bounded guest launch and tree waits.
-          step.openLink ||
           // runScript http calls are synchronous with a 5-minute upstream
           // timeout — the 10s watchdog would kill legitimate setup scripts.
           step.runScript ||
@@ -3386,6 +3441,7 @@ export class SootSimBridgeFlowRunner {
           // waitForAnimationToEnd ends at its own timeout, which a flow may set
           // past 10s, and continues as maestro does on a screen still moving.
           step.waitForAnimationToEnd ||
+          step.advanceAnimationClock ||
           // assertions wait out maestro's lookup window, longer than 10s, and
           // every query they make times out on its own, so they report their
           // own failure instead of the watchdog's guess.
@@ -3399,7 +3455,9 @@ export class SootSimBridgeFlowRunner {
       // launchApp self-governs with an internal waitForTree (120s on a
       // clearState reload): a cache-cleared reload of a heavy bundle re-fetches
       // every chunk from metro and routinely needs more than the step ceiling.
-      if (isContainer || step.launchApp) {
+      // openLink relaunches the guest through the same bounded reload and tree
+      // wait, so it governs itself the same way.
+      if (isContainer || step.launchApp || step.openLink) {
         const result = await body
         if (typeof result === 'string') screenshotPath = result
       } else {
@@ -3423,6 +3481,11 @@ export class SootSimBridgeFlowRunner {
           if (timer) clearTimeout(timer)
         }
       }
+      // Orchestra.executeCommand restarts the lookup window after every
+      // command that returns mutating; containers leave it to their children.
+      if (!isContainer && !NON_MUTATING_STEPS.some((key) => step[key] !== undefined)) {
+        this.lastInteractionAt = Date.now()
+      }
       const isAssertion = !!(
         step.assertVisible ||
         step.assertNotVisible ||
@@ -3480,6 +3543,25 @@ export class SootSimBridgeFlowRunner {
   }
 
   private async runStepInner(step: MaestroStep) {
+    if (
+      this.animationClockLocked &&
+      !step.advanceAnimationClock &&
+      !step.takeScreenshot &&
+      !step.assertVisible &&
+      !step.assertNotVisible &&
+      step.assertTrue === undefined &&
+      !step.assertTreeContains &&
+      !step.dumpTree &&
+      step.copyTextFrom === undefined &&
+      typeof step.evalScript !== 'string' &&
+      !step.runScript &&
+      step.setClipboard === undefined &&
+      !step.runFlow &&
+      !step.repeat &&
+      !step.retry
+    ) {
+      await this.releaseAnimationClock()
+    }
     if (step.tapOn) await this.tapOn(step.tapOn)
     else if (step.doubleTapOn) {
       // maestro YamlFluentCommand: doubleTapOn is tapOn with TapRepeat(2, delay)
@@ -3534,6 +3616,8 @@ export class SootSimBridgeFlowRunner {
             ? waitSpec.timeout
             : 2000,
       )
+    } else if (step.advanceAnimationClock !== undefined) {
+      await this.advanceAnimationClock(step.advanceAnimationClock)
     } else if (step.back) {
       await this.back()
     } else if (step.hideKeyboard) {
@@ -3766,41 +3850,49 @@ export class SootSimBridgeFlowRunner {
   async runFlow(steps: (MaestroStep | string)[], options: { skipPlan?: boolean } = {}) {
     const { onStart, onComplete, body } = this.extractFlowBody(steps)
     this.lastInteractionAt = Date.now()
+    this.flowDepth++
 
-    if (!options.skipPlan && this.liveStatus) {
-      await this.planFlow(steps)
-    }
+    try {
+      if (!options.skipPlan && this.liveStatus) {
+        await this.planFlow(steps)
+      }
 
-    if (onStart.length > 0) {
-      console.log(`[flow] onFlowStart (${onStart.length} steps)`)
-      for (let i = 0; i < onStart.length; i++) {
-        await this.runStep(onStart[i], i)
+      if (onStart.length > 0) {
+        console.log(`[flow] onFlowStart (${onStart.length} steps)`)
+        for (let i = 0; i < onStart.length; i++) {
+          await this.runStep(onStart[i], i)
+        }
       }
-    }
 
-    let caughtError: Error | null = null
-    try {
-      await this.runFlowBody(body)
-    } catch (err) {
-      caughtError = err instanceof Error ? err : new Error(String(err))
-    }
+      let caughtError: Error | null = null
+      try {
+        await this.runFlowBody(body)
+      } catch (err) {
+        caughtError = err instanceof Error ? err : new Error(String(err))
+      }
 
-    if (onComplete.length > 0) {
-      console.log(`[flow] onFlowComplete (${onComplete.length} steps)`)
-      for (let i = 0; i < onComplete.length; i++) {
-        try {
-          await this.runStep(onComplete[i], i)
-        } catch (hookErr) {
-          console.warn(
-            `[flow]   onFlowComplete step ${i + 1} failed: ${
-              hookErr instanceof Error ? hookErr.message : hookErr
-            }`,
-          )
+      if (onComplete.length > 0) {
+        console.log(`[flow] onFlowComplete (${onComplete.length} steps)`)
+        for (let i = 0; i < onComplete.length; i++) {
+          try {
+            await this.runStep(onComplete[i], i)
+          } catch (hookErr) {
+            console.warn(
+              `[flow]   onFlowComplete step ${i + 1} failed: ${
+                hookErr instanceof Error ? hookErr.message : hookErr
+              }`,
+            )
+          }
         }
       }
-    }
 
-    if (caughtError) throw caughtError
+      if (caughtError) throw caughtError
+    } finally {
+      this.flowDepth = Math.max(0, this.flowDepth - 1)
+      if (this.flowDepth === 0) {
+        await this.releaseAnimationClock()
+      }
+    }
   }
 
   private async runFlowBody(steps: MaestroStep[]) {