@devicelab/maestro-runner-darwin-arm64 1.1.29 → 1.1.31

package/README.md

@@ -20,7 +20,9 @@
 [![npm](https://img.shields.io/npm/v/maestro-runner?label=npm&color=cb3837)](https://www.npmjs.com/package/maestro-runner)
 [![CI](https://github.com/devicelab-dev/maestro-runner/actions/workflows/ci.yml/badge.svg)](https://github.com/devicelab-dev/maestro-runner/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/devicelab-dev/maestro-runner/branch/main/graph/badge.svg)](https://codecov.io/gh/devicelab-dev/maestro-runner)
-[![Go Report Card](https://goreportcard.com/badge/github.com/devicelab-dev/maestro-runner?v=2)](https://goreportcard.com/report/github.com/devicelab-dev/maestro-runner)
+[![last release](https://img.shields.io/github/release-date/devicelab-dev/maestro-runner?label=last%20release)](https://github.com/devicelab-dev/maestro-runner/releases)
+[![platforms](https://img.shields.io/badge/platforms-Android%20%7C%20iOS%20%7C%20Web-3a9d5c)](https://open.devicelab.dev/maestro-runner/docs/getting-started)
+[![docs](https://img.shields.io/badge/docs-open.devicelab.dev-17a2b8)](https://open.devicelab.dev/maestro-runner/docs/getting-started)
 
 <b><a href="https://open.devicelab.dev/maestro-runner">Documentation</a></b> | <b><a href="#install">Get Started</a></b> | <b><a href="https://open.devicelab.dev/maestro-runner/docs/cli-reference">CLI Reference</a></b> | <b><a href="https://open.devicelab.dev/maestro-runner/docs/flow-commands">Flow Commands</a></b> | <b><a href="CONTRIBUTING.md">Contributing</a></b>
 
@@ -75,6 +77,14 @@ maestro-runner --driver appium --appium-url <server-url> test flow.yaml # Appium
 maestro-runner test --parallel 3 flows/                                 # Parallel on 3 devices
 ```
 
+## AI coding agents
+
+```bash
+maestro-runner skills install    # writes ~/.claude/skills/maestro-runner/SKILL.md
+```
+
+Installs a skill that tells Claude Code (and other agents that read `SKILL.md`) how to write Maestro flows, run them with maestro-runner, inspect the screen and read the reports. `--dir` writes it elsewhere (`.claude/skills/maestro-runner` in a repository), `--print` prints it. The file carries the binary's version and is replaced when you install from a newer release.
+
 ## Key Features
 
 - **Zero migration** — Runs your existing Maestro YAML flows as-is, no changes needed
@@ -94,7 +104,7 @@ maestro-runner test --parallel 3 flows/                                 # Parall
 - **scrollUntilVisible** — Native scroll implementation that reliably finds off-screen elements
 - **Relative selectors** — Find elements by position: below, above, leftOf, rightOf, childOf
 - **JavaScript scripting** — Embedded JS runtime with HTTP client for dynamic test logic, no external dependencies
-- **Configurable timeouts** — Per-command and per-flow timeouts, `--wait-for-idle-timeout 0` to disable
+- **Configurable timeouts** — Per-command and per-flow timeouts, `--find-timeout 3000` to make a wrong selector fail in 3 s instead of 17 s, `--wait-for-idle-timeout 0` to disable
 - **Lightweight** — Single binary, no JVM required
 
 ## Supported Platforms & Drivers
@@ -104,7 +114,7 @@ maestro-runner test --parallel 3 flows/                                 # Parall
 | **DeviceLab** | Android | Default since v1.1.28. On-device WebSocket driver, ~2x faster than UIAutomator2. |
 | **UIAutomator2** | Android | `--driver uiautomator2`. Direct connection to the device, no external server needed. |
 | **DeviceLab** | iOS | Default since v1.1.28. The DeviceLab iOS agent, on simulators and real iPhones (real iPhones need `--team-id`). `--driver devicelab-legacy` keeps the previous runner. |
-| **WDA (WebDriverAgent)** | iOS | `--driver wda`. Supports simulators and physical devices. |
+| **WDA (WebDriverAgent)** | iOS | `--driver wda`. Supports simulators and physical devices. `--reuse-wda` leaves WebDriverAgent running between runs and reuses it. |
 | **Browser (CDP)** | Web | `--platform web`. Chrome/Chromium automation via Chrome DevTools Protocol. |
 | **Appium** | Android & iOS | `--driver appium`. For cloud testing providers and existing Appium infrastructure. |
 
@@ -195,7 +205,8 @@ Turn it off with `MAESTRO_RUNNER_NO_TELEMETRY=1` or `DO_NOT_TRACK=1`. Set
 `MAESTRO_RUNNER_TELEMETRY_DEBUG=1` to print the event instead of sending it.
 [Telemetry](https://open.devicelab.dev/maestro-runner/docs/telemetry) lists every field.
 
-The update check is separate and unchanged.
+The update check is separate: `MAESTRO_RUNNER_NO_UPDATE_CHECK=1` turns it off,
+and on CI the notice is not printed.
 
 ## Contributing
 

package/drivers/ios/DevicelabIOSRunner/DevicelabIOSRunnerUITests/ATTRIBUTION.md

@@ -63,6 +63,22 @@ The only intentional local edits are:
    60 → 240 chars/sec (matches WDA's `FBTypeText` default). RN inputs
    accept this rate without dropping characters.
 
+8. `RunnerTests+Snapshot.swift` collapsed tab fallback: ported from
+   upstream's fix for wide sliders wedging the runner (agent-device #3776,
+   commit 92db564a3, MIT), adapted to this file. The fallback reads its
+   candidates in one predicate query instead of every descendant one
+   attribute at a time, starts that query only while the snapshot's 8 s
+   processing budget still covers what the root snapshot took (otherwise the
+   snapshot reports `truncated`), and no longer treats a slider as a
+   collapsed container. Candidate `hittable` comes from geometry instead of
+   a per-element XCTest call.
+9. `RunnerTests+Lifecycle.swift` `activateTarget`: when the target app was
+   in the background, wait (at most 2 s) for SpringBoard to go quiescent
+   after `activate()`. The idea comes from WebDriverAgent's
+   `-[XCUIApplication fb_activate]` (appium/appium-ios PR #82, Apache License
+   2.0): after a resume the next tap could report success without reaching
+   the app.
+
 The wire-protocol contract (`RunnerTests+Models.swift` Command/Response shapes,
 HTTP/JSON transport in `RunnerTests+Transport.swift`, dispatch behaviour in
 `RunnerTests+CommandExecution.swift`) is **agent-device's contract** — the

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

@@ -237,14 +237,47 @@ extension RunnerTests {
       target.state.rawValue,
       reason
     )
+    let resuming = isBackgrounded(target.state)
     // activate avoids terminating and relaunching the target app
     target.activate()
+    if resuming {
+      waitForSpringBoardAfterResume()
+    }
     currentApp = target
     currentBundleId = bundleId
     needsFirstInteractionDelay = true
     return target
   }
 
+  /// True for an app that is running but not on screen: activating it is a
+  /// resume, not a launch.
+  func isBackgrounded(_ state: XCUIApplication.State) -> Bool {
+#if os(iOS)
+    return state == .runningBackground || state == .runningBackgroundSuspended
+#else
+    return false
+#endif
+  }
+
+  /// Waits, capped at resumeSpringBoardIdleTimeout, for SpringBoard to go
+  /// idle with its animations done. After a backgrounded app is brought back
+  /// the app itself can already look idle while SpringBoard is still
+  /// finishing the switch, and the next tap was reported as performed but
+  /// never reached the app. Waiting on SpringBoard, only on this resume path,
+  /// is the fix WebDriverAgent took (appium/appium-ios#82, Apache-2.0).
+  func waitForSpringBoardAfterResume() {
+    let started = ProcessInfo.processInfo.systemUptime
+    let outcome = RunnerXCTestTimeouts.waitForQuiescence(
+      of: springboard,
+      timeout: resumeSpringBoardIdleTimeout
+    )
+    NSLog(
+      "AGENT_DEVICE_RUNNER_RESUME_WAIT outcome=%d waited_ms=%.0f",
+      outcome.rawValue,
+      (ProcessInfo.processInfo.systemUptime - started) * 1000
+    )
+  }
+
   func withTemporaryScrollIdleTimeoutIfSupported(
     _ target: XCUIApplication,
     operation: () -> Void

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

@@ -20,6 +20,13 @@ extension RunnerTests {
   // 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
+  // How long one fast snapshot may run before the collapsed tab fallback's
+  // query no longer starts (agent-device's tree slice, #3776). XCTest cannot
+  // cancel a query once it runs on the main thread, so the check is made
+  // before it starts.
+  private static let collapsedTabProcessingBudget: TimeInterval = 8.0
+  // The least time a query is admitted with (agent-device's sweep budget).
+  private static let minimumQueryBudget: TimeInterval = 0.1
 
   private struct SnapshotTraversalContext {
     // The app actually read. A no-bundle snapshot can move to the app in
@@ -27,6 +34,9 @@ extension RunnerTests {
     let app: XCUIApplication
     let queryRoot: XCUIElement
     let rootSnapshot: XCUIElementSnapshot
+    // How long reading rootSnapshot took: what one more query over the
+    // whole tree is expected to cost.
+    let rootReadDuration: TimeInterval
     let viewport: CGRect
     let occlusion: OcclusionIndex
     let maxDepth: Int
@@ -173,6 +183,7 @@ extension RunnerTests {
   }
 
   func snapshotFast(app requested: XCUIApplication, options: SnapshotOptions) -> Response {
+    let processingDeadline = Date().addingTimeInterval(Self.collapsedTabProcessingBudget)
     if let blocking = blockingSystemAlertSnapshot() {
       return Response(ok: true, data: blocking)
     }
@@ -192,20 +203,22 @@ extension RunnerTests {
     }
     let app = context.app
 
-    var cachedDescendantElements: [XCUIElement]?
-    func collapsedTabDescendants() -> [XCUIElement] {
-      if let cachedDescendantElements {
-        return cachedDescendantElements
-      }
-      let fetched = safeSnapshotElementsQuery {
-        context.queryRoot.descendants(matching: .any).allElementsBoundByIndex
+    var nodes: [SnapshotNode] = []
+    var truncated = false
+
+    // Read at most once per snapshot, and only when a collapsed container
+    // asks. A query that could not start leaves the tree marked truncated.
+    var cachedCollapsedTabCandidates: [CollapsedTabCandidate]?
+    func collapsedTabCandidatesOnce() -> [CollapsedTabCandidate] {
+      if let cachedCollapsedTabCandidates {
+        return cachedCollapsedTabCandidates
       }
-      cachedDescendantElements = fetched
-      return fetched
+      let candidates = collapsedTabCandidates(context: context, processingDeadline: processingDeadline)
+      if candidates == nil { truncated = true }
+      cachedCollapsedTabCandidates = candidates ?? []
+      return candidates ?? []
     }
 
-    var nodes: [SnapshotNode] = []
-    var truncated = false
     let rootEvaluation = evaluateSnapshot(context.rootSnapshot, in: context)
     nodes.append(
       makeSnapshotNode(
@@ -220,7 +233,8 @@ extension RunnerTests {
       let didTruncateFallback = appendCollapsedTabFallbackNodes(
         to: &nodes,
         containerSnapshot: context.rootSnapshot,
-        resolveElements: collapsedTabDescendants,
+        resolveCandidates: collapsedTabCandidatesOnce,
+        viewport: context.viewport,
         depth: 1,
         parentIndex: 0,
         nodeLimit: fastSnapshotLimit
@@ -301,7 +315,8 @@ extension RunnerTests {
         let didTruncateFallback = appendCollapsedTabFallbackNodes(
           to: &nodes,
           containerSnapshot: snapshot,
-          resolveElements: collapsedTabDescendants,
+          resolveCandidates: collapsedTabCandidatesOnce,
+          viewport: context.viewport,
           depth: visibleDepth + 1,
           parentIndex: index,
           nodeLimit: nodeLimit
@@ -504,6 +519,7 @@ extension RunnerTests {
     options: SnapshotOptions
   ) -> SnapshotTraversalContext? {
     var app = requested
+    var readStarted = Date()
     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
@@ -512,18 +528,21 @@ extension RunnerTests {
       let front = foregroundTarget(app)
       if front !== app {
         app = front
+        readStarted = Date()
         captured = captureRootSnapshot(app: app, options: options)
       }
     }
     guard let (queryRoot, rootSnapshot) = captured else {
       return nil
     }
+    let rootReadDuration = Date().timeIntervalSince(readStarted)
 
     let viewport = snapshotViewport(app: app, rootSnapshot: queryRoot === app ? rootSnapshot : nil)
     return SnapshotTraversalContext(
       app: app,
       queryRoot: queryRoot,
       rootSnapshot: rootSnapshot,
+      rootReadDuration: rootReadDuration,
       viewport: viewport,
       occlusion: OcclusionIndex(root: rootSnapshot, viewport: viewport, isOccluding: isOccludingType),
       maxDepth: options.depth ?? Int.max
@@ -634,7 +653,12 @@ extension RunnerTests {
   }
 
   private func snapshotValueText(_ snapshot: XCUIElementSnapshot) -> String? {
-    guard let value = snapshot.value else { return nil }
+    Self.valueText(snapshot.value)
+  }
+
+  /// An element's value as a node publishes it; blank reads as no value.
+  private static func valueText(_ value: Any?) -> String? {
+    guard let value else { return nil }
     let text = String(describing: value).trimmingCharacters(in: .whitespacesAndNewlines)
     return text.isEmpty ? nil : text
   }
@@ -687,14 +711,16 @@ extension RunnerTests {
   private func appendCollapsedTabFallbackNodes(
     to nodes: inout [SnapshotNode],
     containerSnapshot: XCUIElementSnapshot,
-    resolveElements: () -> [XCUIElement],
+    resolveCandidates: () -> [CollapsedTabCandidate],
+    viewport: CGRect,
     depth: Int,
     parentIndex: Int,
     nodeLimit: Int
   ) -> Bool {
     let fallbackNodes = collapsedTabFallbackNodes(
       for: containerSnapshot,
-      resolveElements: resolveElements,
+      resolveCandidates: resolveCandidates,
+      viewport: viewport,
       startingIndex: nodes.count,
       depth: depth,
       parentIndex: parentIndex
@@ -706,26 +732,131 @@ extension RunnerTests {
     return fallbackNodes.count > remaining
   }
 
+  /// One live element a collapsed tab container may adopt, as the matching
+  /// query's predicate read it.
+  private struct CollapsedTabCandidate {
+    let type: XCUIElement.ElementType
+    let frame: CGRect
+    let label: String
+    let identifier: String
+    let valueText: String?
+    let enabled: Bool
+    let focused: Bool
+    let selected: Bool
+  }
+
+  // Ported from agent-device #3776 (MIT): a wide slider qualified for this
+  // fallback, which then read every live descendant of the app one attribute
+  // at a time on the XCTest main thread — one round trip each, which nothing
+  // can cancel — so a crowded screen kept the runner busy until it was
+  // treated as wedged. Candidates now come from one query whose predicate
+  // applies the type, geometry and content rules and copies each match's
+  // attributes as XCTest evaluates it, and the query starts only while the
+  // time left before processingDeadline covers what the root snapshot took.
+  // nil means it did not start.
+  private func collapsedTabCandidates(
+    context: SnapshotTraversalContext,
+    processingDeadline: Date
+  ) -> [CollapsedTabCandidate]? {
+    let containerFrames = Self.snapshotDescendants(of: context.rootSnapshot)
+      .filter { isCollapsedTabContainer($0) }
+      .map(\.frame)
+    if containerFrames.isEmpty { return [] }
+    let expectedCost = max(Self.minimumQueryBudget, context.rootReadDuration)
+    guard processingDeadline.timeIntervalSinceNow >= expectedCost else {
+      NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_TAB_FALLBACK_QUERY_NOT_STARTED")
+      return nil
+    }
+    var candidates: [CollapsedTabCandidate] = []
+    let predicate = NSPredicate { object, _ in
+      guard let attributes = object as? XCUIElementAttributes,
+        Self.hasCollapsedTabContent(attributes),
+        containerFrames.contains(where: {
+          Self.isCollapsedTabCandidate(type: attributes.elementType, frame: attributes.frame, in: $0)
+        })
+      else {
+        return false
+      }
+      candidates.append(self.collapsedTabCandidate(attributes))
+      return true
+    }
+    let matches = safeSnapshotElementsQuery {
+      context.queryRoot.descendants(matching: .any).matching(predicate).allElementsBoundByIndex
+    }
+    return matches.isEmpty ? [] : candidates
+  }
+
+  private func collapsedTabCandidate(_ attributes: XCUIElementAttributes) -> CollapsedTabCandidate {
+    var focused = false
+    _ = RunnerObjCExceptionCatcher.catchException({
+      if let value = (attributes as? NSObject)?.value(forKey: "hasFocus") as? Bool {
+        focused = value
+      }
+    })
+    return CollapsedTabCandidate(
+      type: attributes.elementType,
+      frame: attributes.frame,
+      label: attributes.label.trimmingCharacters(in: .whitespacesAndNewlines),
+      identifier: attributes.identifier.trimmingCharacters(in: .whitespacesAndNewlines),
+      valueText: Self.valueText(attributes.value),
+      enabled: attributes.isEnabled,
+      focused: focused,
+      selected: attributes.isSelected
+    )
+  }
+
+  /// Every descendant of `root` in its captured snapshot, without `root`.
+  private static func snapshotDescendants(of root: XCUIElementSnapshot) -> [XCUIElementSnapshot] {
+    var descendants: [XCUIElementSnapshot] = []
+    var stack = Array(root.children.reversed())
+    while let snapshot = stack.popLast() {
+      descendants.append(snapshot)
+      stack.append(contentsOf: snapshot.children.reversed())
+    }
+    return descendants
+  }
+
+  /// A collapsed tab container's item: a candidate type, smaller than the
+  /// container, and centred inside it.
+  private static func isCollapsedTabCandidate(
+    type: XCUIElement.ElementType,
+    frame: CGRect,
+    in containerFrame: CGRect
+  ) -> Bool {
+    guard collapsedTabCandidateTypes.contains(type), !frame.isNull, !frame.isEmpty else {
+      return false
+    }
+    if frame.equalTo(containerFrame) { return false }
+    let area = max(CGFloat(1), frame.width * frame.height)
+    let containerArea = max(CGFloat(1), containerFrame.width * containerFrame.height)
+    return area < containerArea * 0.9 && containerFrame.contains(CGPoint(x: frame.midX, y: frame.midY))
+  }
+
+  /// Whether an element names something a flow can address: a label,
+  /// identifier or value that is not blank.
+  private static func hasCollapsedTabContent(_ attributes: XCUIElementAttributes) -> Bool {
+    [attributes.label, attributes.identifier]
+      .contains { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
+      || valueText(attributes.value) != nil
+  }
+
   private func collapsedTabFallbackNodes(
     for containerSnapshot: XCUIElementSnapshot,
-    resolveElements: () -> [XCUIElement],
+    resolveCandidates: () -> [CollapsedTabCandidate],
+    viewport: CGRect,
     startingIndex: Int,
     depth: Int,
     parentIndex: Int
   ) -> [SnapshotNode] {
-    if !containerSnapshot.children.isEmpty { return [] }
-    guard shouldExpandCollapsedTabContainer(containerSnapshot) else { return [] }
+    guard isCollapsedTabContainer(containerSnapshot) else { return [] }
     let containerFrame = containerSnapshot.frame
-    if containerFrame.isNull || containerFrame.isEmpty { return [] }
 
-    // Collapsed tab containers should be rare, so a full descendant scan is acceptable once per
-    // snapshot as a fallback for XCTest omitting the tab children from the snapshot tree.
-    let elements = resolveElements()
-    let candidates = elements.compactMap { element in
+    let candidates = resolveCandidates().compactMap { candidate in
       collapsedTabCandidateNode(
-        element: element,
+        candidate: candidate,
         containerSnapshot: containerSnapshot,
-        containerFrame: containerFrame
+        containerFrame: containerFrame,
+        viewport: viewport
       )
     }
     .sorted { left, right in
@@ -772,64 +903,41 @@ extension RunnerTests {
   }
 
   private func collapsedTabCandidateNode(
-    element: XCUIElement,
+    candidate: CollapsedTabCandidate,
     containerSnapshot: XCUIElementSnapshot,
-    containerFrame: CGRect
+    containerFrame: CGRect,
+    viewport: CGRect
   ) -> SnapshotNode? {
-    var node: SnapshotNode?
-    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
-      if !element.exists { return }
-      let elementType = element.elementType
-      if !Self.collapsedTabCandidateTypes.contains(elementType) { return }
-      let frame = element.frame
-      if frame.isNull || frame.isEmpty { return }
-      if frame.equalTo(containerFrame) { return }
-      let area = max(CGFloat(1), frame.width * frame.height)
-      let containerArea = max(CGFloat(1), containerFrame.width * containerFrame.height)
-      if area >= containerArea * 0.9 { return }
-      let center = CGPoint(x: frame.midX, y: frame.midY)
-      if !containerFrame.contains(center) { return }
-
-      let label = element.label.trimmingCharacters(in: .whitespacesAndNewlines)
-      let identifier = element.identifier.trimmingCharacters(in: .whitespacesAndNewlines)
-      let valueText = snapshotValueText(element)
-      let hasContent = !label.isEmpty || !identifier.isEmpty || valueText != nil
-      if !hasContent { return }
-      if sameSemanticElement(
-        containerSnapshot: containerSnapshot,
-        elementType: elementType,
-        label: label,
-        identifier: identifier
-      ) {
-        return
-      }
-
-      node = SnapshotNode(
-        index: 0,
-        type: elementTypeName(elementType),
-        label: label.isEmpty ? nil : label,
-        identifier: identifier.isEmpty ? nil : identifier,
-        value: valueText,
-        placeholderValue: nil,
-        rect: snapshotRect(from: frame),
-        enabled: element.isEnabled,
-        focused: elementHasFocus(element) ? true : nil,
-        selected: element.isSelected ? true : nil,
-        hittable: element.isHittable,
-        depth: 0,
-        parentIndex: nil,
-        hiddenContentAbove: nil,
-        hiddenContentBelow: nil
-      )
-    })
-    if let exceptionMessage {
-      NSLog(
-        "AGENT_DEVICE_RUNNER_SNAPSHOT_TAB_FALLBACK_IGNORED_EXCEPTION=%@",
-        exceptionMessage
-      )
+    if !Self.isCollapsedTabCandidate(type: candidate.type, frame: candidate.frame, in: containerFrame) {
+      return nil
+    }
+    if sameSemanticElement(
+      containerSnapshot: containerSnapshot,
+      elementType: candidate.type,
+      label: candidate.label,
+      identifier: candidate.identifier
+    ) {
       return nil
     }
-    return node
+    return SnapshotNode(
+      index: 0,
+      type: elementTypeName(candidate.type),
+      label: candidate.label.isEmpty ? nil : candidate.label,
+      identifier: candidate.identifier.isEmpty ? nil : candidate.identifier,
+      value: candidate.valueText,
+      placeholderValue: nil,
+      rect: snapshotRect(from: candidate.frame),
+      enabled: candidate.enabled,
+      focused: candidate.focused ? true : nil,
+      selected: candidate.selected ? true : nil,
+      // Read from geometry: asking XCTest would be one more round trip per
+      // item, the cost this fallback no longer pays.
+      hittable: candidate.enabled && isVisibleInViewport(candidate.frame, viewport),
+      depth: 0,
+      parentIndex: nil,
+      hiddenContentAbove: nil,
+      hiddenContentBelow: nil
+    )
   }
 
   private func snapshotHasFocus(_ snapshot: XCUIElementSnapshot) -> Bool {
@@ -846,24 +954,23 @@ extension RunnerTests {
     return snapshot.isSelected
   }
 
-  private func shouldExpandCollapsedTabContainer(_ snapshot: XCUIElementSnapshot) -> Bool {
+  /// A wide tab bar or segmented control that XCTest reports without
+  /// children. Sliders no longer qualify (agent-device #3776): a wide slider
+  /// has no items to adopt, and qualifying sent every screen with one
+  /// through the descendant query.
+  private func isCollapsedTabContainer(_ snapshot: XCUIElementSnapshot) -> Bool {
+    if !snapshot.children.isEmpty { return false }
     let frame = snapshot.frame
     if frame.isNull || frame.isEmpty { return false }
     if frame.width < max(CGFloat(160), frame.height * 1.75) { return false }
     switch snapshot.elementType {
-    case .tabBar, .segmentedControl, .slider:
+    case .tabBar, .segmentedControl:
       return true
     default:
       return false
     }
   }
 
-  private func snapshotValueText(_ element: XCUIElement) -> String? {
-    let text = String(describing: element.value ?? "")
-      .trimmingCharacters(in: .whitespacesAndNewlines)
-    return text.isEmpty ? nil : text
-  }
-
   private func sameSemanticElement(
     containerSnapshot: XCUIElementSnapshot,
     elementType: XCUIElement.ElementType,

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

@@ -58,6 +58,9 @@ final class RunnerTests: XCTestCase {
   // a caller polling snapshots during settle paid it on each following
   // interaction.
   let firstInteractionAfterActivateDelay: TimeInterval = 0.1
+  // The most a resume (activating a backgrounded app) waits for SpringBoard
+  // to go idle. WebDriverAgent saw lost taps with no wait and none with 2 s.
+  let resumeSpringBoardIdleTimeout: TimeInterval = 2.0
   // 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.