agent-device 0.20.10 → 0.21.1

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunner.xcodeproj/project.pbxproj

@@ -113,6 +113,7 @@
 			);
 			name = AgentDeviceRunnerUITests;
 			packageProductDependencies = (
+				A1B2C3D4E5F60718293A4B5D /* AgentDeviceSnapshotPresentation */,
 			);
 			productName = AgentDeviceRunnerUITests;
 			productReference = 20EA2EDD2F2CFC7C001CF0EF /* AgentDeviceRunnerUITests.xctest */;
@@ -146,6 +147,9 @@
 			);
 			mainGroup = 20EA2EBD2F2CFC7B001CF0EF;
 			minimizedProjectReferenceProxies = 1;
+			packageReferences = (
+				A1B2C3D4E5F60718293A4B5C /* XCLocalSwiftPackageReference "snapshot-presentation" */,
+			);
 			preferredProjectObjectVersion = 77;
 			productRefGroup = 20EA2EC72F2CFC7B001CF0EF /* Products */;
 			projectDirPath = "";
@@ -157,6 +161,21 @@
 		};
 /* End PBXProject section */
 
+/* Begin XCLocalSwiftPackageReference section */
+		A1B2C3D4E5F60718293A4B5C /* XCLocalSwiftPackageReference "snapshot-presentation" */ = {
+			isa = XCLocalSwiftPackageReference;
+			relativePath = ../../snapshot-presentation;
+		};
+/* End XCLocalSwiftPackageReference section */
+
+/* Begin XCSwiftPackageProductDependency section */
+		A1B2C3D4E5F60718293A4B5D /* AgentDeviceSnapshotPresentation */ = {
+			isa = XCSwiftPackageProductDependency;
+			package = A1B2C3D4E5F60718293A4B5C /* XCLocalSwiftPackageReference "snapshot-presentation" */;
+			productName = AgentDeviceSnapshotPresentation;
+		};
+/* End XCSwiftPackageProductDependency section */
+
 /* Begin PBXResourcesBuildPhase section */
 		20EA2EC42F2CFC7B001CF0EF /* Resources */ = {
 			isa = PBXResourcesBuildPhase;

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.h

@@ -49,6 +49,18 @@ FOUNDATION_EXPORT NSString *const RunnerAXSnapshotCustomActionsBlockedKey;
                                            customActionLimit:(NSInteger)customActionLimit
                                                     deadline:(nullable NSDate *)deadline;
 
+/// The capture behind `snapshotTreeForApplication:`, for an AX client and target
+/// application element that are already resolved. Every request, extension, and
+/// custom-action decision happens here; the application entry point only resolves
+/// the two identities.
++ (NSDictionary<NSString *, id> *)snapshotTreeWithClient:(id)axClient
+                                                  target:(id)target
+                                                maxDepth:(NSInteger)maxDepth
+                                                maxNodes:(NSInteger)maxNodes
+                                  deepExtensionCallLimit:(NSInteger)deepExtensionCallLimit
+                                       customActionLimit:(NSInteger)customActionLimit
+                                                deadline:(nullable NSDate *)deadline;
+
 /// Names of the element's UIAccessibilityCustomActions, or nil when it has
 /// none.
 ///

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.m

@@ -104,7 +104,27 @@ typedef id (*RunnerAXSnapshotMsgSend)(id, SEL, id, id, id, NSError **);
     if (nil == target) {
       return [self failure:@"Could not match active AX application for XCTest application"];
     }
+    return [self snapshotTreeWithClient:axClient
+                                 target:target
+                               maxDepth:maxDepth
+                               maxNodes:maxNodes
+                 deepExtensionCallLimit:deepExtensionCallLimit
+                      customActionLimit:customActionLimit
+                               deadline:deadline];
+  } @catch (NSException *exception) {
+    return [self failure:exception.reason ?: exception.name ?: @"AX snapshot bridge exception"];
+  }
+}
 
++ (NSDictionary<NSString *, id> *)snapshotTreeWithClient:(id)axClient
+                                                  target:(id)target
+                                                maxDepth:(NSInteger)maxDepth
+                                                maxNodes:(NSInteger)maxNodes
+                                  deepExtensionCallLimit:(NSInteger)deepExtensionCallLimit
+                                       customActionLimit:(NSInteger)customActionLimit
+                                                deadline:(nullable NSDate *)deadline
+{
+  @try {
     NSArray *attributes = [self snapshotAttributes];
     NSError *error = nil;
     id root = [self requestSnapshotFromClient:axClient

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

@@ -0,0 +1,36 @@
+struct RunnerAlertPresentation: Equatable {
+  let title: String
+  let content: [String]
+  let buttons: [String]
+}
+
+enum RunnerAlertObservation {
+  case visible(RunnerAlertPresentation)
+  case absent
+  case unavailable
+  case deadlineExceeded
+}
+
+enum RunnerAlertVerification: Equatable {
+  case disappeared
+  case presentationChanged
+  case stillVisible
+  case unconfirmed
+  case timedOut
+
+  static func verify(
+    original: RunnerAlertPresentation,
+    observation: RunnerAlertObservation
+  ) -> RunnerAlertVerification {
+    switch observation {
+    case .visible(let current):
+      return original == current ? .stillVisible : .presentationChanged
+    case .absent:
+      return .disappeared
+    case .unavailable:
+      return .unconfirmed
+    case .deadlineExceeded:
+      return .timedOut
+    }
+  }
+}

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/RunnerStringNormalization.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+extension String {
+  var trimmedNonEmpty: String? {
+    let trimmed = trimmingCharacters(in: .whitespacesAndNewlines)
+    return trimmed.isEmpty ? nil : trimmed
+  }
+}

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.h

@@ -2,6 +2,10 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+FOUNDATION_EXPORT NSInteger RunnerContinuousDragFrameCount(double durationMs);
+FOUNDATION_EXPORT NSInteger RunnerControlledScrollFrameCount(double durationMs);
+FOUNDATION_EXPORT double RunnerControlledScrollProgress(double t);
+
 @interface RunnerSynthesizedGesture : NSObject
 
 + (NSString * _Nullable)synthesizeSwipeWithApplication:(id)application
@@ -15,9 +19,16 @@ NS_ASSUME_NONNULL_BEGIN
                                                              x:(double)x
                                                              y:(double)y
                                                             x2:(double)x2
-                                                            y2:(double)y2
+                                                             y2:(double)y2
                                                      durationMs:(double)durationMs;
 
++ (NSString * _Nullable)synthesizeControlledScrollWithApplication:(id)application
+                                                                x:(double)x
+                                                                y:(double)y
+                                                               x2:(double)x2
+                                                                y2:(double)y2
+                                                        durationMs:(double)durationMs;
+
 + (NSString * _Nullable)synthesizeTapWithApplication:(id)application
                                                    x:(double)x
                                                    y:(double)y;

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.m

@@ -29,6 +29,7 @@ typedef id (*RunnerDragPointerPathFactory)(
   CGPoint,
   double
 );
+typedef double (*RunnerDragProgressFunction)(double);
 
 static NSString * _Nullable RunnerResolveGestureEventBridge(
   id application,
@@ -56,6 +57,21 @@ static id RunnerContinuousDragPointerPath(
   CGPoint end,
   double durationMs
 );
+static id RunnerControlledScrollPointerPath(
+  const RunnerGestureEventBridge *bridge,
+  CGPoint start,
+  CGPoint end,
+  double durationMs
+);
+static id RunnerSampledDragPointerPath(
+  const RunnerGestureEventBridge *bridge,
+  CGPoint start,
+  CGPoint end,
+  double durationMs,
+  RunnerDragProgressFunction progress,
+  NSInteger frameCount
+);
+static double RunnerSmoothstepProgress(double t);
 static NSString * _Nullable RunnerTrySynthesizeDrag(
   id application,
   CGPoint start,
@@ -68,6 +84,8 @@ static NSString * _Nullable RunnerTrySynthesizeTap(id application, CGPoint point
 // XCTest's proven swipe profile reaches the endpoint in 100 ms, then holds for the planned
 // fling duration. Fast movement is what lets UIKit distinguish a fling from a timed pan.
 static const NSTimeInterval RunnerSwipeMovementDurationSeconds = 0.1;
+static const double RunnerDragSampleIntervalMs = 16.0;
+static const NSInteger RunnerControlledScrollMaxFrameCount = 30;
 static id RunnerTapPointerPath(
   const RunnerGestureEventBridge *bridge,
   CGPoint point
@@ -115,6 +133,26 @@ static id RunnerTapPointerPath(
   }
 }
 
++ (NSString * _Nullable)synthesizeControlledScrollWithApplication:(id)application
+                                                                x:(double)x
+                                                                y:(double)y
+                                                               x2:(double)x2
+                                                                y2:(double)y2
+                                                        durationMs:(double)durationMs {
+  @try {
+    return RunnerTrySynthesizeDrag(
+      application,
+      CGPointMake(x, y),
+      CGPointMake(x2, y2),
+      durationMs,
+      @"agent-device-controlled-scroll",
+      RunnerControlledScrollPointerPath
+    );
+  } @catch (NSException *exception) {
+    return RunnerFormatXCTestException(exception, @"private XCTest event synthesis failed");
+  }
+}
+
 + (NSString * _Nullable)synthesizeTapWithApplication:(id)application
                                                    x:(double)x
                                                    y:(double)y {
@@ -351,6 +389,46 @@ static id RunnerContinuousDragPointerPath(
   CGPoint start,
   CGPoint end,
   double durationMs
+) {
+  // This is velocity shaping, not just interpolation density: smoothstep's endpoint slope is zero,
+  // while a planned linear segment reaches lift with nonzero velocity unless a destination hold
+  // follows it. UIKit uses finger-up velocity for scroll deceleration. See ADR 0013 and issue #1586.
+  return RunnerSampledDragPointerPath(
+    bridge,
+    start,
+    end,
+    durationMs,
+    RunnerSmoothstepProgress,
+    RunnerContinuousDragFrameCount(durationMs)
+  );
+}
+
+static id RunnerControlledScrollPointerPath(
+  const RunnerGestureEventBridge *bridge,
+  CGPoint start,
+  CGPoint end,
+  double durationMs
+) {
+  // A stationary hold is not a reliable zero-velocity release in XCTest. Cubic ease-out decreases
+  // velocity from the first movement and reaches near zero before lift. Profiles that accelerate
+  // after pan recognition can still be classified as flings despite a slow final sample.
+  return RunnerSampledDragPointerPath(
+    bridge,
+    start,
+    end,
+    durationMs,
+    RunnerControlledScrollProgress,
+    RunnerControlledScrollFrameCount(durationMs)
+  );
+}
+
+static id RunnerSampledDragPointerPath(
+  const RunnerGestureEventBridge *bridge,
+  CGPoint start,
+  CGPoint end,
+  double durationMs,
+  RunnerDragProgressFunction progress,
+  NSInteger frameCount
 ) {
   id path =
     ((RunnerMsgSendInitPath)objc_msgSend)([bridge->core.pathClass alloc], bridge->initPathSelector, start, 0.0);
@@ -358,14 +436,10 @@ static id RunnerContinuousDragPointerPath(
     return nil;
   }
 
-  // This is velocity shaping, not just interpolation density: smoothstep's endpoint slope is zero,
-  // while a planned linear segment reaches lift with nonzero velocity unless a destination hold
-  // follows it. UIKit uses finger-up velocity for scroll deceleration. See ADR 0013 and issue #1586.
-  int frameCount = MAX(3, (int)(durationMs / 16.0));
   NSTimeInterval durationSeconds = durationMs / 1000.0;
-  for (int index = 1; index <= frameCount; index += 1) {
+  for (NSInteger index = 1; index <= frameCount; index += 1) {
     double t = (double)index / (double)frameCount;
-    double easedT = t * t * (3.0 - 2.0 * t);
+    double easedT = progress(t);
     CGPoint point = CGPointMake(
       start.x + (end.x - start.x) * easedT,
       start.y + (end.y - start.y) * easedT
@@ -377,6 +451,26 @@ static id RunnerContinuousDragPointerPath(
   return path;
 }
 
+static double RunnerSmoothstepProgress(double t) {
+  return t * t * (3.0 - 2.0 * t);
+}
+
+NSInteger RunnerContinuousDragFrameCount(double durationMs) {
+  return MAX(3, (NSInteger)(durationMs / RunnerDragSampleIntervalMs));
+}
+
+NSInteger RunnerControlledScrollFrameCount(double durationMs) {
+  return MIN(
+    RunnerControlledScrollMaxFrameCount,
+    MAX(3, (NSInteger)ceil(durationMs / RunnerDragSampleIntervalMs) - 1)
+  );
+}
+
+double RunnerControlledScrollProgress(double t) {
+  double remaining = 1.0 - t;
+  return 1.0 - remaining * remaining * remaining;
+}
+
 static id RunnerTapPointerPath(
   const RunnerGestureEventBridge *bridge,
   CGPoint point

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: src/snapshot/mobile-snapshot-semantics.ts#isTapPointInsideViewport
-//   TS test: src/snapshot/__tests__/tap-point-policy-parity.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 {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+