fix(runner): bound XCTest's idle wait around alert activation

An alert button is read as hittable before it is tapped, so XCTest's own wait for the app to
idle before synthesizing that tap adds nothing the runner has not already checked. Its default
outlives the command, so the tap lands after the caller was told the alert timed out (#2546).

The helper that bounds that wait was named for the scroll path that owned it; gesture, type and
swipe already went through it, and alert activation now does too, so it is named for the wait it
bounds. Each caller states which of XCTest's two waits it gives up: the gesture, type and swipe
paths skip both, because their next step is a poll of their own, while alert activation drops only
the pre-event wait. Its verification reads the alert this tap replaced, and an alert that dismisses
in order to present an identical replacement passes through a moment with no alert at all — a first
read landing in that moment reported a dismissal nothing had proved.

Author: thymikee

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Alert.swift

@@ -68,7 +68,16 @@ extension RunnerTests {
       guard waitUntilAlertButtonHittable(button, deadline: deadline) else {
         return alertVerificationResponse(.timedOut, action: action, activated: false)
       }
-      let outcome = activateElement(app: alert.ownerApp, element: button, action: "alert \(action)")
+      // The hittable read above is this activation's readiness gate, so XCTest's pre-synthesis wait
+      // adds nothing and can cost more than the command has: the tap would land after the deadline
+      // expired and the alert would be answered by a button the caller was told nothing about
+      // (#2546). The post-tap settle stays, because the verification below reads the alert this tap
+      // replaces; an alert that dismisses and presents an identical replacement passes through a
+      // window with no alert, and a first read landing there reports a dismissal nothing proved.
+      var outcome = RunnerInteractionOutcome.performed
+      withBoundedInteractionIdleTimeoutIfSupported(alert.ownerApp, waits: .preEventSkipped) {
+        outcome = activateElement(app: alert.ownerApp, element: button, action: "alert \(action)")
+      }
       if let response = unsupportedResponse(for: outcome) {
         return response
       }

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift

@@ -97,7 +97,9 @@ extension RunnerTests {
     var outcome = RunnerInteractionOutcome.performed
     let timing = measureGesture {
       if idleTimeout {
-        withTemporaryScrollIdleTimeoutIfSupported(app) { outcome = action() }
+        withBoundedInteractionIdleTimeoutIfSupported(app, waits: .bothSkipped) {
+          outcome = action()
+        }
       } else {
         outcome = action()
       }
@@ -2075,7 +2077,7 @@ extension RunnerTests {
       return Response(ok: true, data: DataPayload(message: "remote pressed"))
     case .type:
       var response: Response?
-      withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
+      withBoundedInteractionIdleTimeoutIfSupported(activeApp, waits: .bothSkipped) {
         response = executeTypeCommand(activeApp: activeApp, command: command)
       }
       return response ?? Response(ok: false, error: ErrorPayload(message: "type produced no response"))
@@ -2087,7 +2089,7 @@ extension RunnerTests {
       // keeps raw measureGesture and only routes the success payload through gestureResponse.
       var executedFrame: DragVisualizationFrame?
       let timing = measureGesture {
-        withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
+        withBoundedInteractionIdleTimeoutIfSupported(activeApp, waits: .bothSkipped) {
           executedFrame = swipe(app: activeApp, direction: direction)
         }
       }

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift

@@ -21,6 +21,24 @@ func runnerCGImage(from image: RunnerImage) -> CGImage? {
 #endif
 }
 
+/// Which of XCTest's two waits around one synthesized event a caller gives up.
+///
+/// The two waits answer to different callers. The pre-event wait is what #2546 bounds: the runner
+/// has already decided the interaction may be synthesized, and XCTest's default wait for the app to
+/// idle outlives a bounded command, so the event lands after the caller was told it failed. The
+/// post-event wait is the settle margin before the runner reads the app back, and a caller whose
+/// verdict is that next read cannot give it up.
+enum RunnerInteractionIdleWaits {
+  /// Neither wait, for a caller whose next step is its own poll rather than a verdict read off this
+  /// event: a scroll re-checks its own content, a text field was already located, a swipe has
+  /// nothing to verify.
+  case bothSkipped
+  /// Pre-event wait dropped, post-event quiescence kept under the same bound, for a caller whose
+  /// verdict is the state this event produced. Alert verification reads the alert the tap replaced,
+  /// and a read taken mid-transition finds no alert and reports a dismissal nothing proved.
+  case preEventSkipped
+}
+
 extension RunnerTests {
   // MARK: - Recording
 
@@ -209,8 +227,14 @@ extension RunnerTests {
     return target
   }
 
-  func withTemporaryScrollIdleTimeoutIfSupported(
+  /// Bounds what XCTest waits around one synthesized event instead of letting it spend a command's
+  /// whole deadline, keeping whichever settle the caller named in `waits`. Callers gate the
+  /// interaction themselves first (a scroll needs no extra wait, a text field is located, an alert
+  /// button is read as hittable), which is what the dropped pre-event wait replaces rather than a
+  /// check the runner skips (#2546).
+  func withBoundedInteractionIdleTimeoutIfSupported(
     _ target: XCUIApplication,
+    waits: RunnerInteractionIdleWaits,
     operation: () -> Void
   ) {
     let setter = NSSelectorFromString("setWaitForIdleTimeout:")
@@ -219,19 +243,20 @@ extension RunnerTests {
       ? (target.value(forKey: "waitForIdleTimeout") as? NSNumber)
       : nil
     if supportsWaitForIdleTimeout {
-      target.setValue(scrollInteractionIdleTimeoutDefault, forKey: "waitForIdleTimeout")
+      target.setValue(interactionIdleTimeoutDefault, forKey: "waitForIdleTimeout")
     }
     defer {
       if let previous {
         target.setValue(previous.doubleValue, forKey: "waitForIdleTimeout")
       }
     }
-    performWithQuiescenceSkippedIfSupported(target, operation: operation)
+    performWithQuiescenceSkippedIfSupported(target, waits: waits, operation: operation)
   }
 
   // Some apps never report post-gesture quiescence, even after XCTest has synthesized the event.
   private func performWithQuiescenceSkippedIfSupported(
     _ target: XCUIApplication,
+    waits: RunnerInteractionIdleWaits,
     operation: () -> Void
   ) {
     let selector = NSSelectorFromString("_performWithInteractionOptions:block:")
@@ -252,12 +277,19 @@ extension RunnerTests {
     )
     let skipPreEventQuiescence = UInt(1)
     let skipPostEventQuiescence = UInt(2)
+    let options: UInt
+    switch waits {
+    case .bothSkipped:
+      options = skipPreEventQuiescence | skipPostEventQuiescence
+    case .preEventSkipped:
+      options = skipPreEventQuiescence
+    }
     withoutActuallyEscaping(operation) { escapableOperation in
       let block: @convention(block) () -> Void = escapableOperation
       performWithOptions(
         target,
         selector,
-        skipPreEventQuiescence | skipPostEventQuiescence,
+        options,
         block
       )
     }

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift

@@ -59,7 +59,7 @@ final class RunnerTests: XCTestCase {
   let retryCooldown: TimeInterval = 0.2
   let postSnapshotInteractionDelay: TimeInterval = 0.2
   let firstInteractionAfterActivateDelay: TimeInterval = 0.25
-  let scrollInteractionIdleTimeoutDefault: TimeInterval = 1.0
+  let interactionIdleTimeoutDefault: TimeInterval = 1.0
   let tvRemoteDoublePressDelayDefault: TimeInterval = 0.0
   // Keep a periodic XCTest liveness marker in runner.log without flooding long-lived sessions.
   let xctestIdleKeepaliveInterval: TimeInterval = 60.0