agent-device 0.21.0 → 0.21.2

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

@@ -1,15 +1,15 @@
 import XCTest
 
-// Swift port of buildScrollGesturePlan from packages/contracts/src/scroll-gesture.ts.
-//
-// This is a deliberate two-place invariant: the daemon keeps the TS implementation (for Android,
-// recording, and reported-pixels), and the runner places the gesture with this Swift copy. Both
-// ports are asserted against the same table, contracts/fixtures/scroll-gesture.json (gated
-// XCTest at the bottom of this file, vitest twin packages/contracts/src/scroll-gesture.test.ts) —
-// if you change the math in either language, update the other and the table.
-//
-// All inputs here are positive (reference dims, travel, center), so Swift's `.rounded()`
-// (half away from zero) matches JS `Math.round` (half up) on every value computed below.
+
+
+
+
+
+
+
+
+
+
 
 struct RunnerScrollGesturePlan {
   let x1: Double
@@ -34,10 +34,10 @@ private let runnerDefaultScrollAmount = 0.6
 private let runnerDefaultIosScrollAmount = 0.65
 private let runnerDefaultIosScrollDurationMs = 400.0
 let runnerDefaultDragDurationMs = 250.0
-// The platform scroll defaults and planner constants are pinned by
-// contracts/fixtures/scroll-gesture.json (`constants`). Scroll gestures stay out of the outer 10%
-// of each axis so a saturated scroll never touches down inside the status bar / Dynamic Island band
-// (#1781 A1).
+
+
+
+
 private let runnerDefaultEdgePaddingFraction = 0.1
 
 func runnerScrollGesturePlan(
@@ -47,9 +47,9 @@ func runnerScrollGesturePlan(
   referenceWidth: Double,
   referenceHeight: Double
 ) -> RunnerScrollGesturePlan? {
-  // Mirror the TS INVALID_ARGS contract: non-positive or non-finite amount/pixels are rejected
-  // rather than clamped into a journaled 1px scroll. The daemon validates before sending, so
-  // this only triggers for non-daemon wire clients.
+
+
+
   if let amount, !(amount.isFinite && amount > 0) { return nil }
   if let pixels, !(pixels.isFinite && pixels > 0) { return nil }
   let axisLength = direction.isVertical ? referenceHeight : referenceWidth
@@ -97,3 +97,202 @@ func runnerDragCommandDefaults(_ command: Command) -> RunnerDragCommandDefaults
   )
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -1,18 +1,18 @@
 import XCTest
 
 extension RunnerTests {
-  // MARK: - Sequence command
 
-  /// Hard cap mirrored from the daemon (MAX_RUNNER_SEQUENCE_STEPS). Keeps the worst-case
-  /// retained journal response well under the 16KB cap and bounds the lost-response window.
+
+
+
   var maxSequenceSteps: Int { 20 }
 
-  /// Allowlisted step kinds. Validated on both sides so an unsupported kind is rejected with a
-  /// clear INVALID_ARGS naming the step index, executing nothing.
+
+
   private var sequenceableStepKinds: Set<String> { ["tap", "doubleTap", "longPress"] }
 
-  /// Per-step outcome carried by `assembleSequenceExecution`. The timing is captured by the
-  /// executor closure (via performGesture) so ordering/stop-on-failure stay device-free testable.
+
+
   struct SequenceStepOutcome {
     let outcome: RunnerInteractionOutcome
     let gestureStartUptimeMs: Double
@@ -34,7 +34,7 @@ extension RunnerTests {
       }
     }
 
-    // Touch frame resolves from the first step's coords so recording-gestures works unchanged.
+
     let firstStep = steps[0]
     let firstFrame = (firstStep.x != nil && firstStep.y != nil)
       ? resolvedTouchVisualizationFrame(app: activeApp, x: firstStep.x!, y: firstStep.y!)
@@ -48,11 +48,11 @@ extension RunnerTests {
     return sequenceResponse(execution: execution, touchFrame: firstFrame)
   }
 
-  /// Pure, device-free assembler: runs each step in order via `perform`, stops at the first
-  /// `.unsupported` outcome, and assembles the DataPayload (completedSteps, optional
-  /// failedStepIndex, per-step results, top-level gesture timing spanning first..last executed).
-  /// Steps after the failed index are never invoked and produce no result entries, so
-  /// results.count == completedSteps + (failedStepIndex != nil ? 1 : 0).
+
+
+
+
+
   func assembleSequenceExecution(
     steps: [SequenceStep],
     perform: (Int, SequenceStep) -> SequenceStepOutcome
@@ -122,7 +122,7 @@ extension RunnerTests {
     let gestureEndUptimeMs: Double?
   }
 
-  // MARK: - Step validation / execution
+
 
   private func validateSequenceStep(_ step: SequenceStep, index: Int) -> Response? {
     guard sequenceableStepKinds.contains(step.kind) else {
@@ -143,9 +143,9 @@ extension RunnerTests {
   ) -> SequenceStepOutcome {
     let x = step.x ?? 0
     let y = step.y ?? 0
-    // Synthesized HID tap fast path mirrors the individual `tap` command (idleTimeout:false, with
-    // a tapAt fallback when synthesis is unsupported), so fusing a jittered tap series does not
-    // change the touch mechanism for these inputs.
+
+
+
     if step.kind == "tap", step.synthesized == true {
       let policyKind = SynthesizedGesturePolicyKind.synthesizedDrag
 #if os(iOS)
@@ -187,12 +187,12 @@ extension RunnerTests {
       }
       logSynthesizedGesturePolicyDecision(kind: policyKind, context: synthesizedContext, fallbackAttempted: true)
 #endif
-      // Synthesis unsupported (e.g. macOS) — fall through to the drag-based tapAt below.
+
     }
     let (timing, outcome) = performGesture(activeApp) {
       switch step.kind {
       case "doubleTap":
-        // doubleTapAt per step, matching the behavior of the retired tapSeries doubleTap path.
+
         return doubleTapAt(app: activeApp, x: x, y: y)
       case "longPress":
         let duration = min(max(step.durationMs ?? 800, 16), 10000) / 1000.0
@@ -201,9 +201,9 @@ extension RunnerTests {
         return tapAt(app: activeApp, x: x, y: y)
       }
     }
-    // Sleep AFTER the step — pauseMs is the inter-step gap — but only when the step performed.
-    // assembleSequenceExecution stops at the first unsupported outcome, so pausing after a failed
-    // step would burn up to 10s of watchdog budget with no following step to separate from.
+
+
+
     if case .performed = outcome, let pauseMs = step.pauseMs, pauseMs > 0 {
       sleepFor(min(max(pauseMs, 0), 10000) / 1000.0)
     }
@@ -240,3 +240,187 @@ extension RunnerTests {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+