@devicelab/maestro-runner-darwin-arm64 1.1.27 → 1.1.28

package/drivers/ios/DevicelabIOSRunner/DevicelabIOSRunnerUITests/RunnerTests+Snapshot.swift

@@ -13,16 +13,99 @@ extension RunnerTests {
     .scrollView,
     .table
   ]
+  // Per-request XPC timeout for a snapshot command's queries, in seconds.
+  // A responsive app answers in well under a second, even on a deep React
+  // Native screen. A suspended app never answers. 3s leaves wide margin for
+  // a busy app and still bounds the stall when the app leaves the screen.
+  // captureRootSnapshot retries a slow root snapshot at XCTest's full
+  // timeout, so this bound cannot cut a large tree short.
+  private static let snapshotRequestTimeout: TimeInterval = 3.0
 
   private struct SnapshotTraversalContext {
+    // The app actually read. A no-bundle snapshot can move to the app in
+    // front when the one it started on leaves the screen.
+    let app: XCUIApplication
     let queryRoot: XCUIElement
     let rootSnapshot: XCUIElementSnapshot
     let viewport: CGRect
-    let flatSnapshots: [XCUIElementSnapshot]
-    let snapshotRanges: [ObjectIdentifier: (Int, Int)]
+    let occlusion: OcclusionIndex
     let maxDepth: Int
   }
 
+  /// Everything the hittable check needs, read once per snapshot. The check
+  /// asks whether any element drawn later (after the node's own subtree, in
+  /// depth-first order) covers the node's centre. It used to re-read every
+  /// later snapshot's frame and type for every node — O(n²) Objective-C
+  /// property reads, seconds on a web page with thousands of nodes. Frames
+  /// are now read once, and only on-screen occluders are kept, so each node
+  /// scans a short precomputed list.
+  struct OcclusionIndex {
+    /// Depth-first position of each snapshot, and the last position inside
+    /// its subtree.
+    let position: [ObjectIdentifier: (start: Int, end: Int)]
+    /// Positions of elements that can cover others (anything but the
+    /// application and its windows) with a frame on screen, ascending.
+    let occluderPositions: [Int]
+    /// Frames, parallel to occluderPositions.
+    let occluderFrames: [CGRect]
+
+    init(root: XCUIElementSnapshot, viewport: CGRect, isOccluding: (XCUIElement.ElementType) -> Bool) {
+      var position: [ObjectIdentifier: (start: Int, end: Int)] = [:]
+      var occluderPositions: [Int] = []
+      var occluderFrames: [CGRect] = []
+      var next = 0
+      @discardableResult
+      func visit(_ snapshot: XCUIElementSnapshot) -> Int {
+        let start = next
+        next += 1
+        let frame = snapshot.frame
+        if isOccluding(snapshot.elementType), !frame.isNull, !frame.isEmpty, frame.intersects(viewport) {
+          occluderPositions.append(start)
+          occluderFrames.append(frame)
+        }
+        var end = start
+        for child in snapshot.children {
+          end = max(end, visit(child))
+        }
+        position[ObjectIdentifier(snapshot)] = (start, end)
+        return end
+      }
+      visit(root)
+      self.position = position
+      self.occluderPositions = occluderPositions
+      self.occluderFrames = occluderFrames
+    }
+
+    /// Whether an element drawn after `snapshot`'s subtree covers `point`.
+    func isCovered(_ snapshot: XCUIElementSnapshot, at point: CGPoint) -> Bool {
+      guard let range = position[ObjectIdentifier(snapshot)] else { return false }
+      // First occluder past the subtree, by binary search.
+      var lo = 0
+      var hi = occluderPositions.count
+      while lo < hi {
+        let mid = (lo + hi) / 2
+        if occluderPositions[mid] <= range.end { lo = mid + 1 } else { hi = mid }
+      }
+      for i in lo..<occluderFrames.count where occluderFrames[i].contains(point) {
+        return true
+      }
+      return false
+    }
+  }
+
+  /// The fraction of `rect` that lies on screen, 0 for an empty rect.
+  static func visibleFraction(_ rect: CGRect, in viewport: CGRect) -> CGFloat {
+    if rect.isNull || rect.isEmpty { return 0 }
+    let area = rect.width * rect.height
+    if area <= 0 { return 0 }
+    let overlap = rect.intersection(viewport)
+    if overlap.isNull || overlap.isEmpty { return 0 }
+    return (overlap.width * overlap.height) / area
+  }
+
+  /// Maestro keeps an element when at least 10% of it is on screen.
+  static let minVisibleFraction: CGFloat = 0.1
+
   private struct SnapshotEvaluation {
     let label: String
     let identifier: String
@@ -89,14 +172,25 @@ extension RunnerTests {
     }
   }
 
-  func snapshotFast(app: XCUIApplication, options: SnapshotOptions) -> DataPayload {
+  func snapshotFast(app requested: XCUIApplication, options: SnapshotOptions) -> Response {
     if let blocking = blockingSystemAlertSnapshot() {
-      return blocking
+      return Response(ok: true, data: blocking)
     }
 
-    guard let context = makeSnapshotTraversalContext(app: app, options: options) else {
-      return DataPayload(nodes: [], truncated: false, appState: appStateString(app))
+    let target = snapshotTarget(requested, options: options)
+    guard let context = makeSnapshotTraversalContext(app: target, options: options) else {
+      // The public snapshot threw (a deep React Native tree makes the AX server
+      // answer kAXErrorIllegalArgument), which would otherwise hand back an
+      // empty tree — the devicelab-vs-WDA RN gap. Recover the tree through the
+      // private AX client instead of returning nothing. Only for an app in
+      // front: one that has left the screen is suspended and cannot answer.
+      if target.state == .runningForeground,
+         let fallback = privateAXFallbackPayload(app: target, options: options) {
+        return Response(ok: true, data: fallback)
+      }
+      return snapshotFailure(target)
     }
+    let app = context.app
 
     var cachedDescendantElements: [XCUIElement]?
     func collapsedTabDescendants() -> [XCUIElement] {
@@ -135,17 +229,37 @@ extension RunnerTests {
     }
 
     var seen = Set<String>()
-    var stack: [(XCUIElementSnapshot, Int, Int, Int?)] = context.rootSnapshot.children.map {
-      ($0, 1, 1, 0)
+    // The last field is true when an ancestor lies wholly off screen: its
+    // descendants' frames are then clipped to the viewport by the app
+    // (Flutter semantics especially) and cannot be trusted as "on screen".
+    var stack: [(XCUIElementSnapshot, Int, Int, Int?, Bool)] = context.rootSnapshot.children.map {
+      ($0, 1, 1, 0, false)
     }
+    let nodeLimit = options.visibleOnly ? visibleSnapshotLimit : fastSnapshotLimit
 
-    while let (snapshot, depth, visibleDepth, parentIndex) = stack.popLast() {
-      if nodes.count >= fastSnapshotLimit {
+    while let (snapshot, depth, visibleDepth, parentIndex, underOffscreen) = stack.popLast() {
+      if nodes.count >= nodeLimit {
         truncated = true
         break
       }
       if let limit = options.depth, depth > limit { continue }
 
+      let frame = snapshot.frame
+      let hasFrame = !frame.isNull && !frame.isEmpty
+      let offscreen = hasFrame && !frame.intersects(context.viewport)
+      if options.visibleOnly
+        && (underOffscreen || Self.visibleFraction(frame, in: context.viewport) < Self.minVisibleFraction) {
+        // Not on screen: leave it out, but keep walking — a frameless
+        // wrapper can hold visible children, and those attach to the
+        // nearest included ancestor.
+        if depth < context.maxDepth {
+          for child in snapshot.children.reversed() {
+            stack.append((child, depth + 1, visibleDepth, parentIndex, underOffscreen || offscreen))
+          }
+        }
+        continue
+      }
+
       let evaluation = evaluateSnapshot(snapshot, in: context)
       let include = shouldInclude(
         snapshot: snapshot,
@@ -167,7 +281,7 @@ extension RunnerTests {
       if depth < context.maxDepth {
         let nextVisibleDepth = include && !isDuplicate ? visibleDepth + 1 : visibleDepth
         for child in snapshot.children.reversed() {
-          stack.append((child, depth + 1, nextVisibleDepth, currentIndex))
+          stack.append((child, depth + 1, nextVisibleDepth, currentIndex, underOffscreen || offscreen))
         }
       }
 
@@ -190,24 +304,36 @@ extension RunnerTests {
           resolveElements: collapsedTabDescendants,
           depth: visibleDepth + 1,
           parentIndex: index,
-          nodeLimit: fastSnapshotLimit
+          nodeLimit: nodeLimit
         )
         truncated = truncated || didTruncateFallback
       }
 
     }
 
-    return DataPayload(nodes: nodes, truncated: truncated, appState: appStateString(app))
+    // A foreground app whose public snapshot yielded only the root node is the
+    // other half of the RN gap: the serializer returned a childless tree on a
+    // screen that plainly has content. Try the private AX path and prefer it
+    // when it recovers more than the root.
+    if nodes.count <= 1, app.state == .runningForeground,
+       let fallback = privateAXFallbackPayload(app: app, options: options),
+       (fallback.nodes?.count ?? 0) > nodes.count {
+      return Response(ok: true, data: fallback)
+    }
+
+    return snapshotSuccess(nodes: nodes, truncated: truncated, app: app)
   }
 
-  func snapshotRaw(app: XCUIApplication, options: SnapshotOptions) -> DataPayload {
+  func snapshotRaw(app requested: XCUIApplication, options: SnapshotOptions) -> Response {
     if let blocking = blockingSystemAlertSnapshot() {
-      return blocking
+      return Response(ok: true, data: blocking)
     }
 
-    guard let context = makeSnapshotTraversalContext(app: app, options: options) else {
-      return DataPayload(nodes: [], truncated: false, appState: appStateString(app))
+    let target = snapshotTarget(requested, options: options)
+    guard let context = makeSnapshotTraversalContext(app: target, options: options) else {
+      return snapshotFailure(target)
     }
+    let app = context.app
 
     var nodes: [SnapshotNode] = []
     var truncated = false
@@ -250,7 +376,50 @@ extension RunnerTests {
     }
 
     walk(context.rootSnapshot, depth: 0, parentIndex: nil)
-    return DataPayload(nodes: nodes, truncated: truncated, appState: appStateString(app))
+    return snapshotSuccess(nodes: nodes, truncated: truncated, app: app)
+  }
+
+  /// A tree read through XCTest's public snapshot API.
+  private func snapshotSuccess(nodes: [SnapshotNode], truncated: Bool, app: XCUIApplication) -> Response {
+    Response(
+      ok: true,
+      data: DataPayload(
+        nodes: nodes,
+        truncated: truncated,
+        appState: appStateString(app),
+        source: SnapshotSource.xctest
+      )
+    )
+  }
+
+  /// A SNAPSHOT_FAILED reply for an app whose tree cannot be read in its
+  /// current state, or nil when a read is worth trying. A suspended app never
+  /// answers — querying it only burns the request timeout — and an app that
+  /// is not running has no tree. A snapshot does not launch or activate the
+  /// app, so this is the honest answer rather than something to fix first.
+  func unreadableSnapshotTarget(_ app: XCUIApplication) -> Response? {
+    switch app.state {
+    case .notRunning, .unknown, .runningBackgroundSuspended:
+      return snapshotFailure(app, reason: "not attempted: the app cannot answer in this state")
+    default:
+      return nil
+    }
+  }
+
+  /// The reply when no tree could be read at all. It used to be ok with an
+  /// empty node list, which a caller cannot tell apart from a screen that is
+  /// really empty, so a timed-out read looked like "nothing on screen". The
+  /// app's state stays in the payload: a suspended app is the usual cause.
+  func snapshotFailure(_ app: XCUIApplication, reason: String = "failed or timed out") -> Response {
+    let state = appStateString(app)
+    return Response(
+      ok: false,
+      data: DataPayload(appState: state),
+      error: ErrorPayload(
+        code: "SNAPSHOT_FAILED",
+        message: "accessibility snapshot \(reason) (appState=\(state))"
+      )
+    )
   }
 
   func snapshotRect(from frame: CGRect) -> SnapshotRect {
@@ -298,48 +467,103 @@ extension RunnerTests {
 
   private func computedSnapshotHittable(
     _ snapshot: XCUIElementSnapshot,
-    viewport: CGRect,
-    laterNodes: ArraySlice<XCUIElementSnapshot>
+    in context: SnapshotTraversalContext
   ) -> Bool {
     guard snapshot.isEnabled else { return false }
     let frame = snapshot.frame
     if frame.isNull || frame.isEmpty { return false }
     let center = CGPoint(x: frame.midX, y: frame.midY)
-    if !viewport.contains(center) { return false }
-    for node in laterNodes {
-      if !isOccludingType(node.elementType) { continue }
-      let nodeFrame = node.frame
-      if nodeFrame.isNull || nodeFrame.isEmpty { continue }
-      if nodeFrame.contains(center) { return false }
+    if !context.viewport.contains(center) { return false }
+    return !context.occlusion.isCovered(snapshot, at: center)
+  }
+
+  /// Runs a snapshot command's queries with a short XPC request timeout, so a
+  /// query against an app that leaves the screen mid-command gives up after
+  /// `snapshotRequestTimeout` instead of XCTest's 30s. That 30s wait would
+  /// also hold every command queued behind this one on the main thread.
+  /// `captureRootSnapshot` retries a slow snapshot of an app that is still
+  /// in front with XCTest's full timeout, so a large tree still completes.
+  func withSnapshotRequestTimeout(_ body: () -> Response) -> Response {
+    var payload: Response?
+    RunnerXCTestTimeouts.withXPCRequestTimeout(Self.snapshotRequestTimeout) {
+      payload = body()
     }
-    return true
+    // The helper runs the block exactly once on every path that returns.
+    return payload!
+  }
+
+  /// The app a snapshot should read. A no-bundle snapshot follows the
+  /// screen. This is checked again here, just before the queries, because
+  /// the alert check that comes first takes long enough for Home to land.
+  private func snapshotTarget(_ requested: XCUIApplication, options: SnapshotOptions) -> XCUIApplication {
+    options.followsScreen ? foregroundTarget(requested) : requested
   }
 
   private func makeSnapshotTraversalContext(
-    app: XCUIApplication,
+    app requested: XCUIApplication,
     options: SnapshotOptions
   ) -> SnapshotTraversalContext? {
-    let viewport = snapshotViewport(app: app)
-    let queryRoot = options.scope.flatMap { findScopeElement(app: app, scope: $0) } ?? app
-
-    let rootSnapshot: XCUIElementSnapshot
-    do {
-      rootSnapshot = try queryRoot.snapshot()
-    } catch {
+    var app = requested
+    var captured = captureRootSnapshot(app: app, options: options)
+    if captured == nil, options.followsScreen, app.state != .runningForeground {
+      // The app left the screen while its snapshot was in flight. A
+      // no-bundle snapshot reads whatever is in front, so read the app that
+      // is in front now. The next command would do the same.
+      let front = foregroundTarget(app)
+      if front !== app {
+        app = front
+        captured = captureRootSnapshot(app: app, options: options)
+      }
+    }
+    guard let (queryRoot, rootSnapshot) = captured else {
       return nil
     }
 
-    let (flatSnapshots, snapshotRanges) = flattenedSnapshots(rootSnapshot)
+    let viewport = snapshotViewport(app: app, rootSnapshot: queryRoot === app ? rootSnapshot : nil)
     return SnapshotTraversalContext(
+      app: app,
       queryRoot: queryRoot,
       rootSnapshot: rootSnapshot,
       viewport: viewport,
-      flatSnapshots: flatSnapshots,
-      snapshotRanges: snapshotRanges,
+      occlusion: OcclusionIndex(root: rootSnapshot, viewport: viewport, isOccluding: isOccludingType),
       maxDepth: options.depth ?? Int.max
     )
   }
 
+  /// Snapshots `app`, or the element `options.scope` names in it. Returns nil
+  /// when the snapshot fails.
+  ///
+  /// A failure that took the whole request timeout means XCTest stopped
+  /// waiting for the app to answer. If the app is still in front, the tree
+  /// may simply be slow to serialize, so the snapshot is tried once more with
+  /// XCTest's own timeout, the behavior before the short timeout existed.
+  /// If the app has left the screen, it gets no second wait: a suspended app
+  /// does not answer.
+  private func captureRootSnapshot(
+    app: XCUIApplication,
+    options: SnapshotOptions
+  ) -> (XCUIElement, XCUIElementSnapshot)? {
+    let queryRoot = options.scope.flatMap { findScopeElement(app: app, scope: $0) } ?? app
+    let started = ProcessInfo.processInfo.systemUptime
+    if let root = try? queryRoot.snapshot() {
+      return (queryRoot, root)
+    }
+    let elapsed = ProcessInfo.processInfo.systemUptime - started
+    guard elapsed >= Self.snapshotRequestTimeout * 0.9 else {
+      return nil
+    }
+    let state = app.state
+    NSLog("DL_SNAPSHOT_REQUEST_TIMEOUT elapsed=%.1f state=%d", elapsed, state.rawValue)
+    guard state == .runningForeground else {
+      return nil
+    }
+    var root: XCUIElementSnapshot?
+    RunnerXCTestTimeouts.withXPCRequestTimeout(RunnerXCTestTimeouts.defaultXPCRequestTimeout()) {
+      root = try? queryRoot.snapshot()
+    }
+    return root.map { (queryRoot, $0) }
+  }
+
   private func evaluateSnapshot(
     _ snapshot: XCUIElementSnapshot,
     in context: SnapshotTraversalContext
@@ -347,16 +571,11 @@ extension RunnerTests {
     let label = aggregatedLabel(for: snapshot) ?? snapshot.label.trimmingCharacters(in: .whitespacesAndNewlines)
     let identifier = snapshot.identifier.trimmingCharacters(in: .whitespacesAndNewlines)
     let valueText = snapshotValueText(snapshot)
-    let laterNodes = laterSnapshots(
-      for: snapshot,
-      in: context.flatSnapshots,
-      ranges: context.snapshotRanges
-    )
     return SnapshotEvaluation(
       label: label,
       identifier: identifier,
       valueText: valueText,
-      hittable: computedSnapshotHittable(snapshot, viewport: context.viewport, laterNodes: laterNodes),
+      hittable: computedSnapshotHittable(snapshot, in: context),
       focused: snapshotHasFocus(snapshot),
       selected: snapshotIsSelected(snapshot),
       visible: isVisibleInViewport(snapshot.frame, context.viewport)
@@ -414,50 +633,28 @@ extension RunnerTests {
     }
   }
 
-  private func flattenedSnapshots(
-    _ root: XCUIElementSnapshot
-  ) -> ([XCUIElementSnapshot], [ObjectIdentifier: (Int, Int)]) {
-    var ordered: [XCUIElementSnapshot] = []
-    var ranges: [ObjectIdentifier: (Int, Int)] = [:]
-
-    @discardableResult
-    func visit(_ snapshot: XCUIElementSnapshot) -> Int {
-      let start = ordered.count
-      ordered.append(snapshot)
-      var end = start
-      for child in snapshot.children {
-        end = max(end, visit(child))
-      }
-      ranges[ObjectIdentifier(snapshot)] = (start, end)
-      return end
-    }
-
-    _ = visit(root)
-    return (ordered, ranges)
-  }
-
-  private func laterSnapshots(
-    for snapshot: XCUIElementSnapshot,
-    in ordered: [XCUIElementSnapshot],
-    ranges: [ObjectIdentifier: (Int, Int)]
-  ) -> ArraySlice<XCUIElementSnapshot> {
-    guard let (_, subtreeEnd) = ranges[ObjectIdentifier(snapshot)] else {
-      return ordered.suffix(from: ordered.count)
-    }
-    let nextIndex = subtreeEnd + 1
-    if nextIndex >= ordered.count {
-      return ordered.suffix(from: ordered.count)
-    }
-    return ordered.suffix(from: nextIndex)
-  }
-
   private func snapshotValueText(_ snapshot: XCUIElementSnapshot) -> String? {
     guard let value = snapshot.value else { return nil }
     let text = String(describing: value).trimmingCharacters(in: .whitespacesAndNewlines)
     return text.isEmpty ? nil : text
   }
 
-  private func snapshotViewport(app: XCUIApplication) -> CGRect {
+  /// The on-screen rect the hittable and visibility checks measure against.
+  /// When the app's own snapshot is at hand, its windows are read from it
+  /// rather than queried again: each query is another round trip, and another
+  /// full request timeout if the app leaves the screen meanwhile.
+  private func snapshotViewport(app: XCUIApplication, rootSnapshot: XCUIElementSnapshot?) -> CGRect {
+    if let rootSnapshot {
+      let window = rootSnapshot.children.first {
+        $0.elementType == .window && !$0.frame.isNull && !$0.frame.isEmpty
+      }
+      if let window {
+        return window.frame
+      }
+      if !rootSnapshot.frame.isNull && !rootSnapshot.frame.isEmpty {
+        return rootSnapshot.frame
+      }
+    }
     let windows = app.windows.allElementsBoundByIndex
     if let window = windows.first(where: { $0.exists && !$0.frame.isNull && !$0.frame.isEmpty }) {
       return window.frame

package/drivers/ios/DevicelabIOSRunner/DevicelabIOSRunnerUITests/RunnerTests+SystemModal.swift

@@ -42,7 +42,7 @@ extension RunnerTests {
       nodes.append(actionNode)
     }
 
-    return DataPayload(nodes: nodes, truncated: false)
+    return DataPayload(nodes: nodes, truncated: false, source: SnapshotSource.xctest)
     #endif
   }
 

package/drivers/ios/DevicelabIOSRunner/DevicelabIOSRunnerUITests/RunnerTests+Transport.swift

@@ -98,8 +98,13 @@ extension RunnerTests {
 
     do {
       let command = try JSONDecoder().decode(Command.self, from: data)
-      let response = try execute(command: command)
-      return (jsonResponse(status: 200, response: response), command.command == .shutdown)
+      let started = CACurrentMediaTime()
+      var response = try execute(command: command)
+      let elapsedMs = (CACurrentMediaTime() - started) * 1000
+      response.serverMs = (elapsedMs * 10).rounded() / 10
+      let encoded = jsonResponse(status: 200, response: response)
+      NSLog("DL_CMD cmd=%@ ms=%.1f bytes=%d ok=%d", command.command.rawValue, elapsedMs, encoded.count, response.ok ? 1 : 0)
+      return (encoded, command.command == .shutdown)
     } catch {
       return (
         jsonResponse(status: 500, response: Response(ok: false, error: ErrorPayload(message: "\(error)"))),

package/drivers/ios/DevicelabIOSRunner/DevicelabIOSRunnerUITests/RunnerTests.swift

@@ -41,26 +41,34 @@ final class RunnerTests: XCTestCase {
   var currentBundleId: String?
   let maxRequestBytes = 2 * 1024 * 1024
   let maxSnapshotElements = 600
-  let fastSnapshotLimit = 300
+  // Node budgets for the fast snapshot. A full tree (reports) caps at
+  // fastSnapshotLimit. A visibleOnly tree (lookups) counts only elements on
+  // screen, so a long web page no longer loses its footer to the cap; the
+  // higher budget is a guard against a pathological screen, not a working
+  // limit.
+  let fastSnapshotLimit = 1500
+  let visibleSnapshotLimit = 3000
   let mainThreadExecutionTimeout: TimeInterval = 30
   let appExistenceTimeout: TimeInterval = 30
   let retryCooldown: TimeInterval = 0.2
-  // Local edit (not in upstream agent-device): post-snapshot/post-activate
-  // stabilization windows shortened from 0.2 / 0.25 s. Upstream value gives
-  // an AI-driven runner time for layout to settle between a read and the
-  // next interaction; maestro-runner's snapshot is part of selector
-  // resolution that's immediately followed by an interaction at a known
-  // coordinate, so a 50ms window is enough to absorb any in-flight UIKit
-  // layout pass without paying for hypothetical agent latency.
-  let postSnapshotInteractionDelay: TimeInterval = 0.05
+  // Local edit (not in upstream agent-device): the post-activate
+  // stabilization window, shortened from 0.25 s, absorbs the activation
+  // transition before the first interaction. Upstream also slept after every
+  // snapshot; that sleep is gone: a snapshot does not change the screen, and
+  // a caller polling snapshots during settle paid it on each following
+  // interaction.
   let firstInteractionAfterActivateDelay: TimeInterval = 0.1
+  // The idle command's cap when the caller gives none, and the most it may
+  // ask for: well under mainThreadExecutionTimeout, so a wait can never be
+  // mistaken for a hung main thread.
+  static let idleDefaultTimeoutMs: Double = 1000
+  static let idleMaxTimeoutMs: Double = 10000
   let scrollInteractionIdleTimeoutDefault: TimeInterval = 1.0
   let tvRemoteDoublePressDelayDefault: TimeInterval = 0.0
   let minRecordingFps = 1
   let maxRecordingFps = 120
   let minRecordingQuality = 5
   let maxRecordingQuality = 10
-  var needsPostSnapshotInteractionDelay = false
   var needsFirstInteractionDelay = false
   // Local extension: cache the most recent idleCheck screenshot so
   // subsequent calls in the same wait loop only need ONE fresh capture.
@@ -97,13 +105,39 @@ final class RunnerTests: XCTestCase {
 
   // MARK: - XCTest Entry
 
+  override class func setUp() {
+    // WDA's runner defaults: no XCTest screenshots or diagnostic screen
+    // recordings per action, local query evaluation, no autocorrect or
+    // predictive text, keyboard intros dismissed, and XCTest's own alert
+    // handling off (the runner handles alerts itself).
+    DLApplyRunnerDefaults()
+    super.setUp()
+  }
+
   override func setUp() {
     continueAfterFailure = true
+    // XCTest halts a test that "receives control" late (testmanagerd slow to
+    // connect), which stopped the runner; keep it running (WDA PR #664).
+    let halt = NSSelectorFromString("setShouldHaltWhenReceivesControl:")
+    if responds(to: halt) {
+      setValue(NSNumber(value: false), forKey: "shouldHaltWhenReceivesControl")
+    }
+    let resetHalt = NSSelectorFromString("setShouldSetShouldHaltWhenReceivesControl:")
+    if responds(to: resetHalt) {
+      setValue(NSNumber(value: false), forKey: "shouldSetShouldHaltWhenReceivesControl")
+    }
     // Override XCTest's clipped snapshot request params so element trees are
     // complete on deep React Native hierarchies (matches WDA / devicekit-ios).
     DLApplyCompleteSnapshotParams()
   }
 
+  // An XCTest issue (a failed query, an assertion inside XCTest) is logged,
+  // never recorded: recording one ended the long-running test, and with it
+  // the runner, e.g. when a keyboard `.exists` query failed mid-command.
+  override func record(_ issue: XCTIssue) {
+    NSLog("DL_XCTEST_ISSUE type=%d %@", issue.type.rawValue, issue.compactDescription)
+  }
+
   @MainActor
   func testCommand() throws {
     doneExpectation = expectation(description: "agent-device command handled")