agent-device 0.21.0 → 0.21.1

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandJournal.swift

@@ -145,3 +145,293 @@ final class RunnerCommandJournal {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Environment.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-// MARK: - Environment
+
 
 enum RunnerEnv {
   static func resolvePort() -> UInt16 {

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Exceptions.swift

@@ -1,14 +1,14 @@
 import XCTest
 
 extension RunnerTests {
-  /// Runs `block` and returns its value. If it raises an Objective-C exception, logs the message
-  /// under `AGENT_DEVICE_RUNNER_<tag>_IGNORED_EXCEPTION` and returns `fallback`.
-  ///
-  /// Consolidates the catch-log-and-default band-aid the runner uses around exception-prone
-  /// XCUITest queries (flaky `allElementsBoundByIndex` snapshots, stale element reads), giving the
-  /// "silently logged and continued" path one searchable format and one place to add per-tag
-  /// exception telemetry later. `RunnerObjCExceptionCatcher.catchException` takes a non-escaping
-  /// block, so `block` may capture `inout` state.
+
+
+
+
+
+
+
+
   func safely<T>(_ tag: String, _ fallback: T, _ block: () -> T) -> T {
     let (result, exceptionMessage) = catchingObjCException(fallback: fallback, block)
     if let exceptionMessage {
@@ -29,8 +29,8 @@ extension RunnerTests {
     return (result, exceptionMessage)
   }
 
-  /// Optional-returning convenience: returns `nil` on exception (matching the common
-  /// `var x: T?` + catch-and-return-nil shape).
+
+
   func safely<T>(_ tag: String, _ block: () -> T?) -> T? {
     safely(tag, nil, block)
   }

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift

@@ -12,6 +12,9 @@ private struct RunnerUnsupportedOperationError: LocalizedError {
 }
 
 private enum RunnerInterfaceOrientation {
+
+
+
   static let portrait = 1
   static let portraitUpsideDown = 2
   static let landscapeRight = 3
@@ -191,11 +194,11 @@ extension RunnerTests {
     }
   }
 
-  // Maestro-compat gate for the non-hittable coordinate fallback: an element
-  // with no frame at all cannot be coordinate-tapped, otherwise the decision
-  // is the shared TapPointPolicy center-in-frame rule (golden parity table
-  // with the TS twin). app.frame is the frame source here — replay taps
-  // resolved bounds Maestro-style, so the union frame is intentional.
+
+
+
+
+
   private func hasTappableFrame(app: XCUIApplication, element: XCUIElement) -> Bool {
     let frame = element.frame
     if frame.isEmpty {
@@ -204,10 +207,10 @@ extension RunnerTests {
     return TapPointPolicy.isAllowed(elementFrame: frame, windowFrame: app.frame)
   }
 
-  // The tappable on-screen viewport. app.frame is unsuitable: it unions
-  // transformed subtrees, so a closed drawer at negative x inflates it and
-  // out-of-window coordinates still pass containment. Falls back to app.frame
-  // when no window frame is readable.
+
+
+
+
   func onScreenWindowFrame(app: XCUIApplication) -> CGRect {
     let window = app.windows.element(boundBy: 0)
     if window.exists {
@@ -220,11 +223,11 @@ extension RunnerTests {
   }
 
   func queryElement(app: XCUIApplication, selectorKey: String, selectorValue: String) -> Response {
-    // querySelector is a read — it backs get/is/wait and the offscreen-refusal
-    // double-check, none of which mutate. The fail-closed raw-match rule exists
-    // to stop a mutation acting on an unseen duplicate; applying it here would
-    // instead turn a decorative non-hittable duplicate into an AMBIGUOUS_MATCH
-    // for readers that previously resolved the hittable element.
+
+
+
+
+
     let match = findElement(
       app: app,
       selectorKey: selectorKey,
@@ -270,8 +273,8 @@ extension RunnerTests {
     )
   }
 
-  /// Shared ordering for point-hit candidates: smallest area wins, then top-to-bottom,
-  /// left-to-right, then stable element-type order for ties.
+
+
   func smallestElementFirst(_ left: XCUIElement, _ right: XCUIElement) -> Bool {
     let leftArea = max(1, left.frame.width * left.frame.height)
     let rightArea = max(1, right.frame.width * right.frame.height)
@@ -315,37 +318,6 @@ extension RunnerTests {
     return nil
   }
 
-  func textInputAt(app: XCUIApplication, x: Double, y: Double) -> XCUIElement? {
-    return textInputCandidatesAt(app: app, point: CGPoint(x: x, y: y)).first
-  }
-
-  private func textInputCandidatesAt(app: XCUIApplication, point: CGPoint) -> [XCUIElement] {
-    safely("TEXT_INPUT_AT_POINT", []) {
-      // Query the text-input element types directly instead of enumerating the entire tree
-      // (app.descendants(.any).allElementsBoundByIndex snapshots every element and is ~10x
-      // slower — it dominated fill latency because resolveTextEntryElement re-runs this on
-      // each verify/repair poll once the focused field reference goes stale).
-      // Prefer the smallest matching field so nested editable controls win over large containers.
-      [
-        app.textFields,
-        app.secureTextFields,
-        app.searchFields,
-        app.textViews,
-      ]
-        .flatMap { $0.allElementsBoundByIndex }
-        .filter { element in
-          guard element.exists else { return false }
-          let frame = element.frame
-          return isCoordinateTextInputCandidate(
-            enabled: element.isEnabled,
-            frame: frame,
-            point: point
-          )
-        }
-        .sorted(by: smallestElementFirst)
-    }
-  }
-
   private func readableText(for element: XCUIElement) -> String? {
     let label = element.label.trimmingCharacters(in: .whitespacesAndNewlines)
     let identifier = element.identifier.trimmingCharacters(in: .whitespacesAndNewlines)
@@ -417,8 +389,8 @@ extension RunnerTests {
     let coordinate = interactionCoordinate(app: app, x: x, y: y)
     let interval = desktopScrollEventIntervalSeconds(durationMs: durationMs, eventCount: events.count)
     for (index, deltas) in events.enumerated() {
-      // Keep desktop scrolling on XCTest's coordinate API so macOS owns wheel synthesis, natural
-      // scrolling preference handling, and cursor placement instead of posting raw CGEvents.
+
+
       coordinate.scroll(
         byDeltaX: CGFloat(deltas.horizontal),
         deltaY: CGFloat(deltas.vertical)
@@ -513,7 +485,7 @@ extension RunnerTests {
     y2: Double,
     holdDuration: TimeInterval
   ) -> RunnerInteractionOutcome {
-    // tvOS has no coordinate drag. Preserve the direction as a focus move.
+
     let dx = x2 - x
     let dy = y2 - y
     let button: TvRemoteButton = abs(dx) > abs(dy)
@@ -525,9 +497,9 @@ extension RunnerTests {
     return performCoordinateDrag(app: app, x: x, y: y, x2: x2, y2: y2, holdDuration: holdDuration)
   }
 
-  /// Rotates an interface-oriented point into the device-native (portrait) space the
-  /// synthesized event path consumes — synthesized events skip XCTest's orientation
-  /// handling, so without this a landscape tap lands in the wrong place.
+
+
+
   func nativeSynthesizedPoint(
     orientedX x: Double,
     orientedY y: Double,
@@ -545,13 +517,13 @@ extension RunnerTests {
       return CGPoint(x: localY, y: width - localX)
     case RunnerInterfaceOrientation.portraitUpsideDown:
       return CGPoint(x: width - localX, y: height - localY)
-    default:  // portrait or unknown
+    default:
       return CGPoint(x: localX, y: localY)
     }
   }
 
-  /// Rotates an interface-oriented translation vector into the same native
-  /// coordinate space as `nativeSynthesizedPoint`.
+
+
   func nativeSynthesizedVector(
     orientedDx dx: Double,
     orientedDy dy: Double,
@@ -564,7 +536,7 @@ extension RunnerTests {
       return CGVector(dx: dy, dy: -dx)
     case RunnerInterfaceOrientation.portraitUpsideDown:
       return CGVector(dx: -dx, dy: -dy)
-    default:  // portrait or unknown
+    default:
       return CGVector(dx: dx, dy: dy)
     }
   }
@@ -910,8 +882,8 @@ extension RunnerTests {
     screenshotSize: CGSize,
     interfaceOrientation: Int
   ) -> CGRect? {
-    // Physical iOS screenshots can retain portrait dimensions after the interface rotates,
-    // while accessibility frames remain in the logical landscape coordinate space.
+
+
     guard screenshotSize.width.isFinite, screenshotSize.height.isFinite,
       screenshotSize.width > 0,
       screenshotSize.height > 0
@@ -1085,8 +1057,8 @@ extension RunnerTests {
   ) -> RunnerInteractionOutcome {
 #if os(iOS)
     let orientation = Int(RunnerSynthesizedGesture.interfaceOrientation(forApplication: app))
-    // The portable planner and validation use this exact viewport. Using app.frame here can
-    // diverge when XCTest unions transformed/off-screen descendants into the application frame.
+
+
     let frame = CGRect(
       x: plan.viewport.x,
       y: plan.viewport.y,
@@ -1217,4 +1189,220 @@ extension RunnerTests {
   }
 #endif
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 }