agent-device 0.21.0 → 0.21.2

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerScrollViewportPolicy.swift

@@ -0,0 +1,413 @@
+import XCTest
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum RunnerScrollKeyboardClip: Equatable {
+
+  case unobstructed
+
+  case avoided(frame: CGRect, keyboardMinY: Double)
+
+  case occluded(keyboardMinY: Double, visibleHeight: Double)
+}
+
+
+enum RunnerScrollViewport {
+
+
+
+
+
+
+
+  case swipe(planFrame: CGRect, coordinateFrame: CGRect, keyboardMinY: Double?)
+
+  case occluded(keyboardMinY: Double, visibleHeight: Double)
+}
+
+
+
+struct ScrollGestureDispatch {
+  let plan: RunnerScrollGesturePlan
+  let planFrame: CGRect
+  let coordinateFrame: CGRect
+  let keyboardMinY: Double?
+}
+
+
+enum ScrollGestureOutcome {
+  case gesture(ScrollGestureDispatch)
+  case unusableFrame
+  case unusablePlan
+  case occluded(keyboardMinY: Double, visibleHeight: Double)
+}
+
+extension ScrollGestureDispatch {
+
+
+
+
+  func attachingEvidence(to response: Response) -> Response {
+    guard response.ok else { return response }
+    var payload = response.data ?? DataPayload()
+    payload.referenceWidth = Double(planFrame.width)
+    payload.referenceHeight = Double(planFrame.height)
+    guard let keyboardMinY else {
+      return Response(ok: response.ok, data: payload, error: response.error)
+    }
+    payload.keyboardAvoided = true
+    payload.keyboardMinY = keyboardMinY
+    return Response(ok: response.ok, data: payload, error: response.error)
+  }
+}
+
+extension RunnerScrollViewport {
+
+
+  func gestureDispatch(
+    direction: RunnerScrollDirection,
+    amount: Double?,
+    pixels: Double?
+  ) -> ScrollGestureOutcome {
+    switch self {
+    case .occluded(let keyboardMinY, let visibleHeight):
+      return .occluded(keyboardMinY: keyboardMinY, visibleHeight: visibleHeight)
+    case .swipe(let planFrame, let coordinateFrame, let keyboardMinY):
+      guard planFrame.width > 0, planFrame.height > 0 else {
+        return .unusableFrame
+      }
+      guard let plan = runnerScrollGesturePlan(
+        direction: direction,
+        amount: amount,
+        pixels: pixels,
+        referenceWidth: planFrame.width,
+        referenceHeight: planFrame.height
+      ) else {
+        return .unusablePlan
+      }
+      return .gesture(
+        ScrollGestureDispatch(
+          plan: plan,
+          planFrame: planFrame,
+          coordinateFrame: coordinateFrame,
+          keyboardMinY: keyboardMinY
+        )
+      )
+    }
+  }
+}
+
+enum ScrollViewportPolicy {
+
+  static let minVisibleFraction: Double = 0.15
+
+
+
+
+
+  static let accessoryAllowance: Double = 12
+
+
+
+  static let occlusionRunnerCode = "SCROLL_KEYBOARD_OCCLUDES_SURFACE"
+
+
+
+  static func clip(viewport: CGRect, keyboard: CGRect) -> RunnerScrollKeyboardClip {
+    guard isUsable(viewport), isUsable(keyboard) else {
+      return .unobstructed
+    }
+
+
+
+    let swipeCenterX = viewport.minX + viewport.width / 2
+    if swipeCenterX < keyboard.minX || swipeCenterX >= keyboard.maxX {
+      return .unobstructed
+    }
+    let keyboardMinY = keyboard.minY
+    if keyboardMinY >= viewport.maxY || keyboard.maxY <= viewport.minY {
+      return .unobstructed
+    }
+    let visibleHeight = max(0, keyboardMinY - accessoryAllowance - viewport.minY)
+    if visibleHeight < minVisibleFraction * viewport.height {
+      return .occluded(keyboardMinY: keyboardMinY, visibleHeight: visibleHeight)
+    }
+    return .avoided(
+      frame: CGRect(
+        x: viewport.minX,
+        y: viewport.minY,
+        width: viewport.width,
+        height: visibleHeight
+      ),
+      keyboardMinY: keyboardMinY
+    )
+  }
+
+
+
+
+  static func frames(referenceFrame: CGRect, clip: RunnerScrollKeyboardClip) -> RunnerScrollViewport {
+    switch clip {
+    case .unobstructed:
+      return .swipe(planFrame: referenceFrame, coordinateFrame: referenceFrame, keyboardMinY: nil)
+    case .avoided(let frame, let keyboardMinY):
+      return .swipe(planFrame: frame, coordinateFrame: referenceFrame, keyboardMinY: keyboardMinY)
+    case .occluded(let keyboardMinY, let visibleHeight):
+      return .occluded(keyboardMinY: keyboardMinY, visibleHeight: visibleHeight)
+    }
+  }
+
+  private static func isUsable(_ rect: CGRect) -> Bool {
+    return [rect.minX, rect.minY, rect.width, rect.height].allSatisfy(\.isFinite)
+      && rect.width > 0 && rect.height > 0
+  }
+}
+
+extension RunnerTests {
+
+
+
+
+  func resolvedScrollViewport(
+    app: XCUIApplication,
+    context: SynthesizedCoordinateContext
+  ) -> RunnerScrollViewport {
+#if os(iOS)
+
+
+    guard context.allowsKeyboardProbe else {
+      logScrollViewport(decision: "probeSkipped", keyboardMinY: nil, swipeHeight: context.referenceFrame.height, context: context)
+      return ScrollViewportPolicy.frames(referenceFrame: context.referenceFrame, clip: .unobstructed)
+    }
+    guard let keyboardFrame = visibleKeyboardFrame(app: app) else {
+      logScrollViewport(decision: "noKeyboard", keyboardMinY: nil, swipeHeight: context.referenceFrame.height, context: context)
+      return ScrollViewportPolicy.frames(referenceFrame: context.referenceFrame, clip: .unobstructed)
+    }
+    let clip = ScrollViewportPolicy.clip(viewport: context.referenceFrame, keyboard: keyboardFrame)
+    switch clip {
+    case .unobstructed:
+      logScrollViewport(decision: "unobstructed", keyboardMinY: nil, swipeHeight: context.referenceFrame.height, context: context)
+    case .avoided(let frame, let keyboardMinY):
+      logScrollViewport(
+        decision: "avoided",
+        keyboardMinY: keyboardMinY,
+        swipeHeight: frame.height,
+        context: context
+      )
+    case .occluded(let keyboardMinY, let visibleHeight):
+      logScrollViewport(
+        decision: "occluded",
+        keyboardMinY: keyboardMinY,
+        swipeHeight: visibleHeight,
+        context: context
+      )
+    }
+    return ScrollViewportPolicy.frames(referenceFrame: context.referenceFrame, clip: clip)
+#else
+    let fallbackFrame = resolvedTouchReferenceFrame(app: app, appFrame: app.frame)
+    return ScrollViewportPolicy.frames(referenceFrame: fallbackFrame, clip: .unobstructed)
+#endif
+  }
+
+#if os(iOS)
+
+
+
+  private func logScrollViewport(
+    decision: String,
+    keyboardMinY: Double?,
+    swipeHeight: Double,
+    context: SynthesizedCoordinateContext
+  ) {
+    NSLog(
+      "AGENT_DEVICE_RUNNER_SCROLL_VIEWPORT kind=scroll axHealth=%@ keyboardPolicy=%@ decision=%@ keyboardMinY=%@ swipeHeight=%.1f",
+      context.accessibilityHealth.rawValue,
+      context.keyboardPolicy.rawValue,
+      decision,
+      keyboardMinY.map { String(format: "%.1f", $0) } ?? "none",
+      swipeHeight
+    )
+  }
+#endif
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSelectorMatchPolicy.swift

@@ -20,26 +20,26 @@ enum DirectSelectorCandidateDecision: Equatable {
   case ambiguous
 }
 
-/// How many raw exact matches a dispatch may discard before hittability is
-/// allowed to pick a winner. The two rows differ because the cost of guessing
-/// wrong differs, not because the matching differs.
+
+
+
 enum DirectSelectorRawMatchPolicy: Equatable {
-  /// Mutations fail closed: every raw exact match counts, so a hittable
-  /// element can never silently win over a same-selector duplicate the caller
-  /// never saw and act on the wrong one.
+
+
+
   case rejectDistinctMatches
-  /// Reads prefer the single hittable match and ignore non-hittable
-  /// same-selector duplicates. A read has no side effect to guard, and
-  /// `querySelector` backs `get`/`is`/`wait` — failing those closed turns a
-  /// decorative duplicate into an error where the reader previously got its
-  /// answer.
+
+
+
+
+
   case preferHittableMatch
 }
 
-/// Normal direct selector mutations count every raw exact match before
-/// hittability can choose a winner. Reads keep the hittable-preference rule,
-/// and Maestro's explicitly requested coordinate fallback keeps its
-/// point-filtered compatibility behavior.
+
+
+
+
 func classifyDirectSelectorCandidates(
   _ candidates: [SelectorCandidateFacts],
   allowNonHittableFallback: Bool,

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSystemSurfaceHostPolicy.swift

@@ -0,0 +1,72 @@
+import Foundation
+
+
+
+
+
+enum SystemSurfaceHostKind: String {
+  case webAuth = "web-auth"
+}
+
+struct SystemSurfaceHost: Equatable {
+  let bundleId: String
+  let kind: SystemSurfaceHostKind
+}
+
+enum SystemSurfaceHostRegistry {
+  static let hosts: [SystemSurfaceHost] = [
+    SystemSurfaceHost(bundleId: "com.apple.SafariViewService", kind: .webAuth)
+  ]
+
+  static func host(forBundleId bundleId: String?) -> SystemSurfaceHost? {
+    guard let bundleId else { return nil }
+    return hosts.first { $0.bundleId == bundleId }
+  }
+
+  static func isSystemSurfaceHost(_ bundleId: String?) -> Bool {
+    host(forBundleId: bundleId) != nil
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTapPointPolicy.swift

@@ -1,19 +1,19 @@
 import XCTest
 
-// The tap-point rule the runner shares with the TS runtime (ADR 0011 Layer 2).
-//
-// RULE: the tap point is the element frame's CENTER; a tap is allowed iff that
-// center lies inside the window frame, edges inclusive. An empty or invalid
-// window frame fails open (allowed): resolving the best available frame is the
-// impure caller's job (onScreenWindowFrame / app.frame), and the policy must
-// not turn a missing frame into a refusal.
-//
-// This is pure geometry on purpose — no XCUIElement — so the exact decision
-// can be proven against the golden fixture table shared with the TS twin:
-//   table:   contracts/fixtures/tap-point-policy.json
-//   TS twin: packages/contracts/src/snapshot-visibility.ts#isTapPointInsideViewport
-//   TS test: packages/contracts/src/snapshot-tap-point-policy.test.ts
-// Drift on either side turns CI red without needing a simulator.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 enum TapPointPolicy {
   static func isAllowed(elementFrame: CGRect, windowFrame: CGRect) -> Bool {
     if windowFrame.isNull || windowFrame.isEmpty || windowFrame.isInfinite {
@@ -26,3 +26,52 @@ enum TapPointPolicy {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+