@swmansion/argent 0.31.1-next.11 → 0.31.1-next.12

package/dist/cli-cmds.mjs

@@ -35740,7 +35740,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID5();
 function readCliVersion() {
   if (true) {
-    return "0.31.1-next.11";
+    return "0.31.1-next.12";
   }
   return "0.0.0";
 }

package/dist/installer.mjs

@@ -16915,7 +16915,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = randomUUID4();
 function readCliVersion() {
   if (true) {
-    return "0.31.1-next.11";
+    return "0.31.1-next.12";
   }
   return "0.0.0";
 }

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerSession+Commands.swift

@@ -159,6 +159,8 @@ extension ArgentRunnerSession {
             return performLongPress(request, on: app)
         case .drag:
             return performDrag(request, on: app)
+        case .touchPaths:
+            return performTouchPaths(request, on: app)
         case .type:
             return performType(request, on: app)
         case .keyboardReturn:

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerSession+Gestures.swift

@@ -122,6 +122,102 @@ extension ArgentRunnerSession {
         return .success(MessagePayload(message: "dragged"))
     }
 
+    /// Most fingers one `touchPaths` command plays. A hand has five.
+    private static let maxTouchFingers = 5
+    /// Longest `touchPaths` gesture, comfortably inside the command budget.
+    private static let maxTouchPathsMs = 30_000.0
+
+    /// Plays one path per finger, all at once: pinches, rotations, and any
+    /// single path with waypoints. XCUICoordinate only draws one straight drag,
+    /// so this goes through XCTest's event synthesizer (ArgentTouchSynthesizer).
+    ///
+    /// Wire points are absolute screen points, the same space `tap` and `drag`
+    /// take, and times are measured from the start of the gesture. A finger
+    /// whose first waypoint is later than 0 touches down late, which is how a
+    /// second finger joins a gesture already under way.
+    func performTouchPaths(_ request: CommandRequest, on app: XCUIApplication)
+        -> Envelope
+    {
+        guard let fingers = request.fingers,
+            (1...Self.maxTouchFingers).contains(fingers.count)
+        else {
+            return .failure(
+                .invalidRequest,
+                "touchPaths requires between 1 and \(Self.maxTouchFingers) fingers"
+            )
+        }
+
+        for (index, finger) in fingers.enumerated() {
+            guard !finger.points.isEmpty else {
+                return .failure(
+                    .invalidRequest,
+                    "touchPaths finger \(index) has no waypoints"
+                )
+            }
+
+            var previousMs = 0.0
+
+            for point in finger.points {
+                guard point.x.isFinite, point.y.isFinite, point.tMs.isFinite,
+                    point.tMs >= previousMs, point.tMs <= Self.maxTouchPathsMs
+                else {
+                    return .failure(
+                        .invalidRequest,
+                        "touchPaths finger \(index) needs finite waypoints whose times do not decrease and stay within \(Int(Self.maxTouchPathsMs)) ms"
+                    )
+                }
+
+                previousMs = point.tMs
+            }
+        }
+
+        if let reason = ArgentTouchSynthesizer.unavailabilityReason() {
+            return .failure(
+                .unsupportedOperation,
+                "multi-finger touch is unavailable here: \(reason)",
+                hint:
+                    "Use tap, swipe or drag for a single finger, or drive the app's own zoom controls."
+            )
+        }
+
+        // The orientation the app draws in, not the way the phone is held: a
+        // portrait-only app on a phone turned sideways is still portrait. Wire
+        // points are in the app's space, which is the panel's own only in
+        // portrait. Other orientations have not been checked on hardware, and
+        // a touch that lands somewhere else without an error is worse than a
+        // refusal.
+        switch ArgentTouchSynthesizer.interfaceOrientation(ofApplication: app) {
+        case .portrait:
+            break
+        case .unknown:
+            return .failure(
+                .unsupportedOperation,
+                "touchPaths could not read the app's interface orientation",
+                hint:
+                    "Use tap, swipe or drag for a single finger, or drive the app's own zoom controls."
+            )
+        default:
+            return .failure(
+                .unsupportedOperation,
+                "touchPaths has only been verified with the app drawn in portrait",
+                hint: "Turn the phone upright so the app draws in portrait, then retry."
+            )
+        }
+
+        let waypoints = fingers.map { finger in
+            finger.points.map { [$0.x, $0.y, $0.tMs / 1000] as [NSNumber] }
+        }
+
+        if let failure = ArgentTouchSynthesizer.synthesizeFingers(
+            waypoints,
+            interfaceOrientation: .portrait
+        ) {
+            return .failure(.commandFailed, failure)
+        }
+
+        return .success(MessagePayload(message: "touched"))
+    }
+
     /// Reports the interaction viewport, the rectangle that normalized 0-1
     /// coordinates map into.
     func appViewport(_ app: XCUIApplication) -> Envelope {

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerUITests-Bridging-Header.h

@@ -1 +1,2 @@
 #import "ArgentExceptionGuard.h"
+#import "ArgentTouchSynthesizer.h"

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentTouchSynthesizer.h

@@ -0,0 +1,40 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Multi-finger touch synthesis through XCTest's own event classes.
+///
+/// The public XCUICoordinate API can drive one finger along one straight
+/// press-then-drag. Pinches, rotations and any path with waypoints need several
+/// fingers moving at once, which XCTest builds internally from
+/// XCPointerEventPath and XCSynthesizedEventRecord. Those classes are not in
+/// any public header, so they are looked up by name at runtime: nothing links
+/// against a private symbol, and an Xcode that renames or drops one makes
+/// `unavailabilityReason` answer instead of the runner failing to load.
+@interface ArgentTouchSynthesizer : NSObject
+
+/// nil when every class and selector this needs is present, otherwise a
+/// sentence naming what is missing.
++ (NSString *_Nullable)unavailabilityReason;
+
+/// The orientation the app's interface is drawn in, which can differ from the
+/// way the phone is held (a portrait-only app on a phone turned sideways).
+/// UIInterfaceOrientationUnknown when this XCTest cannot say.
++ (UIInterfaceOrientation)interfaceOrientationOfApplication:(id)application;
+
+/// Plays every finger at once as one event record, and returns once the last
+/// finger has lifted. Each finger is an array of `[x, y, seconds]` waypoints:
+/// points in the panel's own portrait space, and the time since the gesture
+/// started. The finger touches down at its first waypoint, moves through the
+/// rest in order, and lifts a hair after its last. Waypoint times must not
+/// decrease.
+///
+/// Returns nil on success, otherwise "Name: reason" for the failure or the
+/// NSException XCTest threw (Swift cannot catch those).
++ (NSString *_Nullable)synthesizeFingers:
+            (NSArray<NSArray<NSArray<NSNumber *> *> *> *)fingers
+                      interfaceOrientation:(UIInterfaceOrientation)orientation;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentTouchSynthesizer.m

@@ -0,0 +1,149 @@
+#import "ArgentTouchSynthesizer.h"
+
+#import <XCTest/XCTest.h>
+#import <objc/message.h>
+
+/// The selectors used on XCTest's private classes, declared as protocols so the
+/// compiler can check the calls without a class symbol to link against.
+@protocol ArgentPointerEventPath <NSObject>
+- (instancetype)initForTouchAtPoint:(CGPoint)point offset:(NSTimeInterval)offset;
+- (void)moveToPoint:(CGPoint)point atOffset:(NSTimeInterval)offset;
+- (void)liftUpAtOffset:(NSTimeInterval)offset;
+@end
+
+@protocol ArgentSynthesizedEventRecord <NSObject>
+- (instancetype)initWithName:(NSString *)name
+                   displayID:(NSUInteger)displayID
+        interfaceOrientation:(UIInterfaceOrientation)orientation;
+- (instancetype)initWithName:(NSString *)name
+        interfaceOrientation:(UIInterfaceOrientation)orientation;
+- (void)addPointerEventPath:(id<ArgentPointerEventPath>)path;
+- (BOOL)synthesizeWithError:(NSError *_Nullable *_Nullable)error;
+@end
+
+/// How long after its last waypoint a finger lifts, so the move and the lift
+/// are two distinct events in the stream.
+static const NSTimeInterval kLiftDelay = 0.01;
+
+@implementation ArgentTouchSynthesizer
+
++ (NSString *_Nullable)unavailabilityReason {
+  Class pathClass = NSClassFromString(@"XCPointerEventPath");
+  Class recordClass = NSClassFromString(@"XCSynthesizedEventRecord");
+
+  if (pathClass == Nil || recordClass == Nil) {
+    return @"this Xcode's XCTest has no XCPointerEventPath/XCSynthesizedEventRecord";
+  }
+
+  SEL pathSelectors[] = {
+      @selector(initForTouchAtPoint:offset:),
+      @selector(moveToPoint:atOffset:),
+      @selector(liftUpAtOffset:),
+  };
+  for (size_t i = 0; i < sizeof(pathSelectors) / sizeof(SEL); i++) {
+    if (![pathClass instancesRespondToSelector:pathSelectors[i]]) {
+      return [NSString stringWithFormat:@"XCPointerEventPath no longer responds to %@",
+                                        NSStringFromSelector(pathSelectors[i])];
+    }
+  }
+
+  // Either record initializer will do; synthesizeFingers picks the newer one.
+  if (![recordClass instancesRespondToSelector:@selector(initWithName:displayID:interfaceOrientation:)] &&
+      ![recordClass instancesRespondToSelector:@selector(initWithName:interfaceOrientation:)]) {
+    return @"XCSynthesizedEventRecord has neither initWithName:displayID:interfaceOrientation: "
+           @"nor initWithName:interfaceOrientation:";
+  }
+
+  SEL recordSelectors[] = {
+      @selector(addPointerEventPath:),
+      @selector(synthesizeWithError:),
+  };
+  for (size_t i = 0; i < sizeof(recordSelectors) / sizeof(SEL); i++) {
+    if (![recordClass instancesRespondToSelector:recordSelectors[i]]) {
+      return [NSString stringWithFormat:@"XCSynthesizedEventRecord no longer responds to %@",
+                                        NSStringFromSelector(recordSelectors[i])];
+    }
+  }
+
+  return nil;
+}
+
++ (UIInterfaceOrientation)interfaceOrientationOfApplication:(id)application {
+  SEL selector = NSSelectorFromString(@"interfaceOrientation");
+  if (![application respondsToSelector:selector]) {
+    return UIInterfaceOrientationUnknown;
+  }
+  return ((UIInterfaceOrientation(*)(id, SEL))objc_msgSend)(application, selector);
+}
+
+/// The main screen's display id, which the display-aware record initializer
+/// routes touches by. nil when XCUIScreen does not expose one.
++ (NSNumber *_Nullable)mainDisplayID {
+  XCUIScreen *screen = XCUIScreen.mainScreen;
+  if (![screen respondsToSelector:NSSelectorFromString(@"displayID")]) {
+    return nil;
+  }
+  id value = [screen valueForKey:@"displayID"];
+  return [value isKindOfClass:NSNumber.class] ? value : nil;
+}
+
+/// A new event record. Prefers the display-aware initializer, which newer
+/// XCTest uses for its own touches, and falls back to the older one when this
+/// XCTest or the screen cannot supply a display id.
++ (id<ArgentSynthesizedEventRecord>)recordWithInterfaceOrientation:
+    (UIInterfaceOrientation)orientation {
+  Class recordClass = NSClassFromString(@"XCSynthesizedEventRecord");
+  NSString *name = @"argent-touch-paths";
+  NSNumber *displayID = [self mainDisplayID];
+
+  if (displayID != nil &&
+      [recordClass instancesRespondToSelector:@selector(initWithName:displayID:interfaceOrientation:)]) {
+    return [[recordClass alloc] initWithName:name
+                                   displayID:displayID.unsignedIntegerValue
+                        interfaceOrientation:orientation];
+  }
+
+  return [[recordClass alloc] initWithName:name interfaceOrientation:orientation];
+}
+
++ (NSString *_Nullable)synthesizeFingers:
+            (NSArray<NSArray<NSArray<NSNumber *> *> *> *)fingers
+                      interfaceOrientation:(UIInterfaceOrientation)orientation {
+  NSString *unavailable = [self unavailabilityReason];
+  if (unavailable != nil) {
+    return unavailable;
+  }
+
+  @try {
+    id<ArgentSynthesizedEventRecord> record = [self recordWithInterfaceOrientation:orientation];
+
+    for (NSArray<NSArray<NSNumber *> *> *waypoints in fingers) {
+      NSArray<NSNumber *> *first = waypoints.firstObject;
+      id<ArgentPointerEventPath> path = [[NSClassFromString(@"XCPointerEventPath") alloc]
+          initForTouchAtPoint:CGPointMake(first[0].doubleValue, first[1].doubleValue)
+                       offset:first[2].doubleValue];
+
+      for (NSUInteger i = 1; i < waypoints.count; i++) {
+        NSArray<NSNumber *> *waypoint = waypoints[i];
+        [path moveToPoint:CGPointMake(waypoint[0].doubleValue, waypoint[1].doubleValue)
+                 atOffset:waypoint[2].doubleValue];
+      }
+
+      [path liftUpAtOffset:waypoints.lastObject[2].doubleValue + kLiftDelay];
+      [record addPointerEventPath:path];
+    }
+
+    NSError *error = nil;
+    if (![record synthesizeWithError:&error]) {
+      return [NSString stringWithFormat:@"XCTest refused the touch events: %@",
+                                        error.localizedDescription ?: @"no error given"];
+    }
+
+    return nil;
+  } @catch (NSException *exception) {
+    return [NSString stringWithFormat:@"%@: %@", exception.name ?: @"NSException",
+                                      exception.reason ?: @"unhandled Objective-C exception"];
+  }
+}
+
+@end

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/RunnerProtocol.swift

@@ -13,6 +13,7 @@ enum CommandKind: String, Codable {
     case tap
     case longPress
     case drag
+    case touchPaths
     case type
     case keyboardReturn
     case keyboardDelete
@@ -30,8 +31,8 @@ extension CommandKind {
         switch self {
         case .status, .viewport, .snapshot, .screenshot:
             return true
-        case .tap, .longPress, .drag, .type, .keyboardReturn, .keyboardDelete,
-            .button, .shutdown:
+        case .tap, .longPress, .drag, .touchPaths, .type, .keyboardReturn,
+            .keyboardDelete, .button, .shutdown:
             return false
         }
     }
@@ -41,8 +42,8 @@ extension CommandKind {
     /// runner's own host app.
     var requiresAppBundleId: Bool {
         switch self {
-        case .viewport, .tap, .longPress, .drag, .type, .keyboardReturn,
-            .keyboardDelete, .snapshot:
+        case .viewport, .tap, .longPress, .drag, .touchPaths, .type,
+            .keyboardReturn, .keyboardDelete, .snapshot:
             return true
         case .status, .button, .screenshot, .shutdown:
             return false
@@ -73,7 +74,7 @@ extension CommandKind {
         // never reports quiescent stalls the wait until XCTest gives up and
         // synthesizes the event anyway, and a shorter budget would abandon a
         // command that still completes.
-        case .tap, .longPress, .drag: return 75
+        case .tap, .longPress, .drag, .touchPaths: return 75
         default: return 30
         }
     }
@@ -90,6 +91,20 @@ enum DeviceButton: String, Codable {
     case actionButton
 }
 
+/// One point on a finger's path: an absolute point in the app's coordinate
+/// space, and the time since the gesture started.
+struct TouchWaypoint: Codable {
+    let x: Double
+    let y: Double
+    let tMs: Double
+}
+
+/// One finger of a `touchPaths` command: it touches down at the first
+/// waypoint, moves through the rest in order, and lifts after the last.
+struct TouchFinger: Codable {
+    let points: [TouchWaypoint]
+}
+
 struct CommandRequest: Codable {
     let command: CommandKind
     let commandId: String?
@@ -119,6 +134,8 @@ struct CommandRequest: Codable {
     /// velocity is near zero and the scroll view does not fling. Mirrors the
     /// simulator's ease-out `settle` swipe.
     let settle: Bool?
+    /// `touchPaths`: one path per finger, all played at once.
+    let fingers: [TouchFinger]?
     /// `type`: the text delivered to the focused input.
     let text: String?
     /// `button`: which hardware button to press.

package/dist/tool-server.cjs

@@ -101024,7 +101024,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = (0, import_node_crypto3.randomUUID)();
 function readCliVersion() {
   if (true) {
-    return "0.31.1-next.11";
+    return "0.31.1-next.12";
   }
   return "0.0.0";
 }
@@ -141439,6 +141439,13 @@ async function dragBetween(api, bundleId, from2, to, opts = {}) {
   );
   return { reactivated: repliedReactivated(data) };
 }
+async function touchPaths(api, bundleId, fingers) {
+  const data = await api.run(
+    { command: "touchPaths", appBundleId: bundleId, fingers },
+    { timeoutMs: GESTURE_TIMEOUT_MS }
+  );
+  return { reactivated: repliedReactivated(data) };
+}
 async function pressButton(api, button) {
   await api.run({
     command: "button",
@@ -142564,13 +142571,33 @@ Pass momentum:false for a momentum-free drag that decelerates into the release,
 
 // ../tool-server/src/tools/gesture-custom/index.ts
 init_zod();
-init_device_info();
-init_capability();
 
 // ../tool-server/src/utils/gesture-utils.ts
 function lerp(a, b, t) {
   return a + (b - a) * t;
 }
+function pinchContacts(params, t) {
+  const angleRad = (params.angle ?? 0) * Math.PI / 180;
+  const cosA = Math.cos(angleRad);
+  const sinA = Math.sin(angleRad);
+  const halfDist = (params.startDistance + (params.endDistance - params.startDistance) * t) / 2;
+  const cx = params.centerX + ((params.endCenterX ?? params.centerX) - params.centerX) * t;
+  const cy = params.centerY + ((params.endCenterY ?? params.centerY) - params.centerY) * t;
+  return {
+    first: { x: cx - halfDist * cosA, y: cy - halfDist * sinA },
+    second: { x: cx + halfDist * cosA, y: cy + halfDist * sinA }
+  };
+}
+function rotateContacts(params, t) {
+  const angleDeg = params.startAngle + (params.endAngle - params.startAngle) * t;
+  const angleRad = angleDeg * Math.PI / 180;
+  const dx = params.radiusX * Math.cos(angleRad);
+  const dy = params.radiusY * Math.sin(angleRad);
+  return {
+    first: { x: params.centerX + dx, y: params.centerY + dy },
+    second: { x: params.centerX - dx, y: params.centerY - dy }
+  };
+}
 function interpolateEvents(events, steps) {
   if (events.length < 2 || steps < 1) return events;
   const result = [];
@@ -142614,7 +142641,59 @@ function sendTouchEvent(api, type, x, y, x2, y2) {
   });
 }
 
+// ../tool-server/src/utils/ios-device/touch-paths.ts
+var FRAME_MS = 16;
+function frameCount(durationMs) {
+  return Math.max(1, Math.round(durationMs / FRAME_MS));
+}
+function twoFingerPaths(viewport, durationMs, contactsAt) {
+  const steps = frameCount(durationMs);
+  const first = { points: [] };
+  const second = { points: [] };
+  for (let i = 0; i <= steps; i++) {
+    const contacts = contactsAt(i / steps);
+    const tMs = i * durationMs / steps;
+    first.points.push({ ...toPoints(viewport, contacts.first.x, contacts.first.y), tMs });
+    second.points.push({ ...toPoints(viewport, contacts.second.x, contacts.second.y), tMs });
+  }
+  return [first, second];
+}
+function pinchPaths(params, viewport, durationMs) {
+  return twoFingerPaths(viewport, durationMs, (t) => pinchContacts(params, t));
+}
+function rotatePaths(params, viewport, durationMs) {
+  return twoFingerPaths(viewport, durationMs, (t) => rotateContacts(params, t));
+}
+function trainPaths(events, viewport) {
+  const down = events[0];
+  const up = events[events.length - 1];
+  if (down?.type !== "Down" || up?.type !== "Up" || events.length < 2) {
+    throw new Error("A touch train starts with a Down and ends with an Up.");
+  }
+  if (events.slice(1, -1).some((event2) => event2.type !== "Move")) {
+    throw new Error("A touch train has only Move events between its Down and its Up.");
+  }
+  const first = { points: [] };
+  const second = { points: [] };
+  let tMs = 0;
+  events.forEach((event2, index) => {
+    if (event2.x2 === void 0 !== (event2.y2 === void 0)) {
+      throw new Error(`Event ${index} has only one of x2 and y2; give both or neither.`);
+    }
+    if (index > 0) {
+      tMs += event2.delayMs ?? FRAME_MS;
+    }
+    first.points.push({ ...toPoints(viewport, event2.x, event2.y), tMs });
+    if (event2.x2 !== void 0 && event2.y2 !== void 0) {
+      second.points.push({ ...toPoints(viewport, event2.x2, event2.y2), tMs });
+    }
+  });
+  return second.points.length > 0 ? [first, second] : [first];
+}
+
 // ../tool-server/src/tools/gesture-custom/index.ts
+init_device_info();
+init_capability();
 var sleep6 = (ms) => new Promise((r) => setTimeout(r, ms));
 var eventSchema = external_exports.object({
   type: external_exports.enum(["Down", "Move", "Up"]).describe("Touch event type"),
@@ -142643,32 +142722,42 @@ function samePoint(a, b) {
   return Math.abs(a.x - b.x) <= SAME_POINT_EPSILON && Math.abs(a.y - b.y) <= SAME_POINT_EPSILON;
 }
 function planIosDeviceGesture(events) {
-  if (events.some((e) => e.x2 !== void 0 || e.y2 !== void 0)) {
-    return {
-      kind: "unsupported",
-      reason: "gesture-custom on a physical iOS device supports single-finger gestures only; two-finger event trains (pinch/rotate) have no XCTest coordinate API."
-    };
-  }
   const down = events[0];
   const up = events[events.length - 1];
-  const hold = events.length === 3 ? events[1] : void 0;
-  const pickup = down !== void 0 && hold !== void 0 && hold.type === "Move" && samePoint(down, hold);
-  if (down === void 0 || up === void 0 || down.type !== "Down" || up.type !== "Up" || !(events.length === 2 || events.length === 3 && pickup)) {
+  if (down === void 0 || up === void 0 || events.length < 2 || down.type !== "Down" || up.type !== "Up" || events.slice(1, -1).some((event2) => event2.type !== "Move")) {
     return {
       kind: "unsupported",
-      reason: "gesture-custom on a physical iOS device supports a Down followed by an Up (same point = press-hold; different points = drag, resting at the Down point for the Up's delayMs before moving), optionally with one Move at the Down point in between (its delayMs is the hold, the Up's delayMs the movement time: a long-press pickup). For scrolls use gesture-swipe; other Move waypoints cannot be replayed through XCTest."
+      reason: "gesture-custom on a physical iOS device takes a Down, any number of Moves, then an Up (a second finger rides along as x2/y2 on those events)."
     };
   }
+  const twoFingers = events.some((e) => e.x2 !== void 0 || e.y2 !== void 0);
+  const hold = events.length === 3 ? events[1] : void 0;
+  const pickup = hold !== void 0 && hold.type === "Move" && samePoint(down, hold);
+  if (twoFingers || !(events.length === 2 || events.length === 3 && pickup)) {
+    return { kind: "paths" };
+  }
   return { kind: "gesture", down, up, ...pickup && hold ? { hold } : {} };
 }
-async function runOnIosDevice(runner, udid, events) {
+async function runOnIosDevice(runner, udid, events, interpolate) {
   const plan = planIosDeviceGesture(events);
   if (plan.kind === "unsupported") {
     throw new InvalidToolInputError(plan.reason);
   }
-  const { down, hold, up } = plan;
   const bundleId = requireCurrentIosDeviceApp(udid);
   const viewport = await getViewport(runner, bundleId);
+  if (plan.kind === "paths") {
+    const played = interpolate && interpolate > 0 ? interpolateEvents(events, interpolate) : events;
+    let fingers;
+    try {
+      fingers = trainPaths(played, viewport);
+    } catch (error63) {
+      throw new InvalidToolInputError(error63.message);
+    }
+    const reply = await touchPaths(runner, bundleId, fingers);
+    const reactivated2 = viewport.reactivated === true || reply.reactivated;
+    return { events: events.length, ...reactivated2 ? { reactivated: true } : {} };
+  }
+  const { down, hold, up } = plan;
   const holdMs = hold ? hold.delayMs ?? 16 : up.delayMs ?? 16;
   const moveMs = hold ? up.delayMs ?? 16 : void 0;
   const gesture = samePoint(down, up) ? await longPressAt(
@@ -142699,7 +142788,7 @@ For simple taps use the gesture-tap tool. For straight-line scrolling use the ge
 For pinch gestures use gesture-pinch. For rotation gestures use gesture-rotate.
 All x/y values are normalized 0.0\u20131.0 (screen fractions, not pixels). delayMs controls the delay before each event (default 16ms \u2248 60fps).
 Set interpolate to auto-generate smooth intermediate Move events between your keyframes.
-Physical iOS: Down then Up only. Same point = press-hold. Other point = drag (Up delayMs = rest before the move). One Move at the Down point between them = long-press pickup (Move delayMs = hold, Up delayMs = move time). No second finger, no other waypoints; scroll with gesture-swipe.
+Physical iOS: a Down, any Moves, then an Up, with an optional second finger as x2/y2. Paths need the app drawn in portrait. A plain Down then Up keeps its hold semantics: same point = press-hold, other point = drag (Up delayMs = rest before the move), and one Move at the Down point between them = long-press pickup (Move delayMs = hold, Up delayMs = move time). Anything else (more Moves, a second finger) plays as timed paths, each event waiting its delayMs after the one before. The second finger touches down at the first event with x2/y2 and lifts after the last.
 Returns { events: number } with the total count of events dispatched. On physical iOS, reactivated: true = app was re-fronted; re-describe. Fails if the target device is not booted or an event type is invalid.
 
 Example long-press at center:
@@ -142719,11 +142808,11 @@ Example pinch-to-zoom (with interpolate:10 for smoothness):
   interpolate: 10`,
   zodSchema: zodSchema21,
   capability: capability13,
-  // Declare the runner only for a train execute can replay. A rejected train must not pay a runner cold start.
+  // Declare the runner only for a train execute can play. A rejected train must not pay a runner cold start.
   services: (params) => {
     const device = resolveDevice(params.udid);
     if (isIosPhysicalDevice(device)) {
-      return planIosDeviceGesture(params.events).kind === "gesture" ? { iosDeviceRunner: iosDeviceRunnerRef(device) } : {};
+      return planIosDeviceGesture(params.events).kind !== "unsupported" ? { iosDeviceRunner: iosDeviceRunnerRef(device) } : {};
     }
     return { simulatorServer: simulatorServerRef(device) };
   },
@@ -142733,7 +142822,8 @@ Example pinch-to-zoom (with interpolate:10 for smoothness):
       return runOnIosDevice(
         services.iosDeviceRunner,
         device.id,
-        params.events
+        params.events,
+        params.interpolate
       );
     }
     const api = services.simulatorServer;
@@ -142786,23 +142876,11 @@ var zodSchema22 = external_exports.object({
   )
 });
 var capability14 = {
-  apple: { simulator: true },
+  apple: { simulator: true, device: true },
   appleRemote: { simulator: true },
   android: { emulator: true, device: true, unknown: true },
   harmony: { device: true }
 };
-function contactsAt(params, t) {
-  const angleRad = (params.angle ?? 0) * Math.PI / 180;
-  const cosA = Math.cos(angleRad);
-  const sinA = Math.sin(angleRad);
-  const halfDist = (params.startDistance + (params.endDistance - params.startDistance) * t) / 2;
-  const cx = params.centerX + ((params.endCenterX ?? params.centerX) - params.centerX) * t;
-  const cy = params.centerY + ((params.endCenterY ?? params.centerY) - params.centerY) * t;
-  return {
-    first: { x: cx - halfDist * cosA, y: cy - halfDist * sinA },
-    second: { x: cx + halfDist * cosA, y: cy + halfDist * sinA }
-  };
-}
 var gesturePinchTool = {
   id: "gesture-pinch",
   interaction: {
@@ -142814,12 +142892,13 @@ var gesturePinchTool = {
 startDistance > endDistance = pinch in (zoom out). startDistance < endDistance = pinch out (zoom in).
 Typical values: startDistance 0.2, endDistance 0.6 for a zoom-in pinch at screen center.
 Auto-generates interpolated frames at ~60fps<flag:harmonyos> on iOS and Android; HarmonyOS takes both fingers' endpoints in one call and interpolates them on-device</flag:harmonyos>. The angle parameter controls the axis (0 = horizontal, 90 = vertical). Optional endCenterX/endCenterY drift the centroid linearly over the gesture (omitted = fixed center).
-Use when you need to zoom in or out on a map, image, or zoomable view. Returns { pinched: true, timestampMs }. Fails if the simulator-server / emulator backend<flag:harmonyos>, or \`hdc\` on HarmonyOS,</flag:harmonyos> is not reachable for the given device.`,
+Use when you need to zoom in or out on a map, image, or zoomable view. Physical iPhones play both fingers through the runner as one event stream. Returns { pinched: true, timestampMs }. On physical iOS, reactivated: true = app was re-fronted; re-describe. Fails if the simulator-server / emulator backend<flag:harmonyos>, or \`hdc\` on HarmonyOS,</flag:harmonyos> is not reachable for the given device, or on a physical iPhone when the app is not drawn in portrait.`,
   zodSchema: zodSchema22,
   capability: capability14,
   services: (params) => {
     const device = resolveDevice(params.udid);
     if (device.platform === "harmony") return {};
+    if (isIosPhysicalDevice(device)) return { iosDeviceRunner: iosDeviceRunnerRef(device) };
     return { simulatorServer: simulatorServerRef(device) };
   },
   async execute(services, params, ctx) {
@@ -142844,8 +142923,8 @@ Use when you need to zoom in or out on a map, image, or zoomable view. Returns {
             )
           );
           assertHarmonyDisplayReady(live, "pinch");
-          const start2 = contactsAt(params, 0);
-          const end = contactsAt(params, 1);
+          const start2 = pinchContacts(params, 0);
+          const end = pinchContacts(params, 1);
           timestampMs2 = Date.now();
           await ui.multiTouchMove(
             [
@@ -142865,13 +142944,26 @@ Use when you need to zoom in or out on a map, image, or zoomable view. Returns {
       );
       return { pinched: true, timestampMs: timestampMs2 };
     }
+    if (isIosPhysicalDevice(device)) {
+      const runner = services.iosDeviceRunner;
+      const bundleId = requireCurrentIosDeviceApp(device.id);
+      const viewport = await getViewport(runner, bundleId);
+      const timestampMs2 = Date.now();
+      const { reactivated } = await touchPaths(
+        runner,
+        bundleId,
+        pinchPaths(params, viewport, duration3)
+      );
+      const fronted = viewport.reactivated === true || reactivated;
+      return { pinched: true, timestampMs: timestampMs2, ...fronted ? { reactivated: true } : {} };
+    }
     const api = services.simulatorServer;
     const steps = Math.max(1, Math.round(duration3 / 16));
     let timestampMs = 0;
     let warning;
     for (let i = 0; i <= steps; i++) {
       const t = i / steps;
-      const { first, second } = contactsAt(params, t);
+      const { first, second } = pinchContacts(params, t);
       const type = i === 0 ? "Down" : i === steps ? "Up" : "Move";
       if (i === 0) timestampMs = Date.now();
       const sent = await sendTouchEvent(api, type, first.x, first.y, second.x, second.y);
@@ -142911,7 +143003,7 @@ var zodSchema23 = external_exports.object({
   message: "Pass radius, or both radiusX and radiusY."
 });
 var capability15 = {
-  apple: { simulator: true },
+  apple: { simulator: true, device: true },
   appleRemote: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -142934,19 +143026,35 @@ var gestureRotateTool = {
 endAngle > startAngle = clockwise rotation. Typical values: radius 0.15, startAngle 0, endAngle 90 for a 90\xB0 clockwise turn. A single radius applies to both axes, so on a non-square screen it traces a physical ellipse (finger separation varies through the turn); pass radiusX+radiusY (fractions of width/height with radiusX\xB7width = radiusY\xB7height) for a physically circular orbit instead.
 Auto-generates interpolated frames at ~60fps.
 Unlike gesture-pinch which moves fingers linearly to zoom, this orbits fingers in an arc to change orientation.
-Use when you need to rotate a map, image picker, or any rotateable UI element. Returns { rotated: true, timestampMs }. Fails if the simulator-server / emulator backend is not reachable for the given device.
+Use when you need to rotate a map, image picker, or any rotateable UI element. Returns { rotated: true, timestampMs }. On physical iOS, reactivated: true = app was re-fronted; re-describe. Fails if the simulator-server / emulator backend is not reachable for the given device, or on a physical iPhone when the app is not drawn in portrait.
 Size the orbit with radius, or with radiusX and radiusY together (the pair overrides radius); one half of the pair alone, or none of the three, is rejected.`,
   zodSchema: zodSchema23,
   capability: capability15,
-  services: (params) => ({
-    simulatorServer: simulatorServerRef(resolveDevice(params.udid))
-  }),
+  services: (params) => {
+    const device = resolveDevice(params.udid);
+    return isIosPhysicalDevice(device) ? { iosDeviceRunner: iosDeviceRunnerRef(device) } : { simulatorServer: simulatorServerRef(device) };
+  },
   async execute(services, params, ctx) {
-    const api = services.simulatorServer;
     const duration3 = params.durationMs ?? 300;
     const steps = Math.max(1, Math.round(duration3 / 16));
     const radiusX = params.radiusX ?? params.radius;
     const radiusY = params.radiusY ?? params.radius;
+    const geometry = { ...params, radiusX, radiusY };
+    const device = resolveDevice(params.udid);
+    if (isIosPhysicalDevice(device)) {
+      const runner = services.iosDeviceRunner;
+      const bundleId = requireCurrentIosDeviceApp(device.id);
+      const viewport = await getViewport(runner, bundleId);
+      const timestampMs2 = Date.now();
+      const { reactivated } = await touchPaths(
+        runner,
+        bundleId,
+        rotatePaths(geometry, viewport, duration3)
+      );
+      const fronted = viewport.reactivated === true || reactivated;
+      return { rotated: true, timestampMs: timestampMs2, ...fronted ? { reactivated: true } : {} };
+    }
+    const api = services.simulatorServer;
     let timestampMs = 0;
     let warning;
     let lastX1 = 0;
@@ -142968,13 +143076,10 @@ Size the orbit with radius, or with radiusX and radiusY together (the pair overr
         }
         throw err;
       }
-      const t = i / steps;
-      const angleDeg = params.startAngle + (params.endAngle - params.startAngle) * t;
-      const angleRad = angleDeg * Math.PI / 180;
-      const x1 = params.centerX + radiusX * Math.cos(angleRad);
-      const y1 = params.centerY + radiusY * Math.sin(angleRad);
-      const x2 = params.centerX - radiusX * Math.cos(angleRad);
-      const y2 = params.centerY - radiusY * Math.sin(angleRad);
+      const {
+        first: { x: x1, y: y1 },
+        second: { x: x2, y: y2 }
+      } = rotateContacts(geometry, i / steps);
       const type = i === 0 ? "Down" : i === steps ? "Up" : "Move";
       if (i === 0) timestampMs = Date.now();
       const sent = await sendTouchEvent(api, type, x1, y1, x2, y2);
@@ -151291,7 +151396,7 @@ function createRunSequenceTool(registry2) {
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to run interaction sequence: ${failureSignal2.error_code}`
     },
     description: `Execute multiple device interaction steps in a single call (iOS simulator or physical device, Android emulator, Apple TV / Android TV, <flag:harmonyos>HarmonyOS device, </flag:harmonyos>or Chromium app).
-On a physical iOS device only gesture-tap, gesture-swipe, gesture-custom, button, keyboard, and await-ui-element steps run; others fail at their own gate.
+On a physical iOS device only gesture-tap, gesture-swipe, gesture-custom, gesture-pinch, gesture-rotate, button, keyboard, and await-ui-element steps run; others fail at their own gate.
 Use when you need sequential actions and do NOT need to observe the screen between them
 (e.g. scrolling multiple times, typing then pressing enter, rotating back and forth).
 Returns { completed, total, steps } with per-step results. Fails if an unrecognised tool name is used in a step (error returned at that step, execution stops).
@@ -153865,7 +153970,7 @@ function formatDescribeTree(root, opts) {
     );
   } else {
     header.push(
-      opts.source === "xcuitest-runner" ? "Pass them straight to gesture-tap / gesture-swipe, which expect this same space. No two-finger gestures on physical iOS." : "Pass them straight to gesture-tap / gesture-swipe / gesture-pinch, which expect this same space."
+      "Pass them straight to gesture-tap / gesture-swipe / gesture-pinch, which expect this same space."
     );
     header.push(
       "To tap an element, use its centre: tap_x = frame.x + frame.width / 2, tap_y = frame.y + frame.height / 2."
@@ -169569,12 +169674,6 @@ async function runDirective(env, step) {
       reason: step.kind === "long-press" ? "long-press is unsupported on HarmonyOS \u2014 `uitest uiInput` has a `longClick` verb, but it takes no hold duration and argent drives holds through `gesture-custom`, which has no HarmonyOS backend; use `tap`" : "rotate is unsupported on HarmonyOS \u2014 `uinput -T -m` is the platform's only multi-contact injection and it moves each finger along ONE straight line per call, with no way to chain segments into an arc; drive the app's own rotate control with `tap`, or `pinch`, which is a straight-line gesture and does run here"
     };
   }
-  if ((step.kind === "pinch" || step.kind === "rotate") && isIosPhysicalDevice(env.device)) {
-    return {
-      ok: false,
-      reason: step.kind === "pinch" ? "pinch is unsupported on a physical iOS device: XCTest exposes no two-finger coordinate API on hardware; run this e2e test on a simulator or drive the app's zoom UI with tap steps instead" : "rotate is unsupported on a physical iOS device: XCTest exposes no two-finger coordinate API on hardware; run this e2e test on a simulator or drive the app's rotate controls with tap steps instead"
-    };
-  }
   if (step.kind === "idle" && !supportsFlowTree(env.device.platform)) {
     return {
       ok: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.31.1-next.11",
+  "version": "0.31.1-next.12",
   "mcpName": "io.github.software-mansion/argent",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",

package/rules/argent.md

@@ -116,7 +116,7 @@ When: Beginning a task that involves the Android emulator, no emulator running y
 
 PHYSICAL iPHONE (USB)
 Skills: `argent-ios-device-setup` (cable, trust, signing), then `argent-ios-device-interact` (the app-scoped interaction contract)
-When: The user names a physical iPhone, a real device, or hardware, or the target `list-devices` iOS entry has kind `"device"`. Never for a simulator, and never because a cabled phone is listed first. On hardware every interaction starts with `launch-app`; `paste`, `settings-permissions`, two-finger gestures, `rotate`, `shake`, screen recording, `debugger-*`, `react-profiler-*`, `native-profiler-*` and `native-*` do not exist there.
+When: The user names a physical iPhone, a real device, or hardware, or the target `list-devices` iOS entry has kind `"device"`. Never for a simulator, and never because a cabled phone is listed first. On hardware every interaction starts with `launch-app`; `paste`, `settings-permissions`, `rotate`, `shake`, screen recording, `debugger-*`, `react-profiler-*`, `native-profiler-*` and `native-*` do not exist there.
 Prompt keywords: physical iPhone, real device, on my phone, USB, hardware
 
 TAPPING, SWIPING, TYPING, GESTURES, SCREENSHOTS, SCROLLING

package/skills/argent-create-e2e/SKILL.md

@@ -13,7 +13,7 @@ For a saved QA test case, ticket, or acceptance criterion, load `argent-qa-e2e`
 
 - Before creating or changing an e2e test, read [Live authoring](references/live-authoring.md) completely.
 - When polishing, composing, or manually reviewing YAML, read [E2E YAML](references/e2e-yaml.md). For Vega, read its platform limits before recording remote or keyboard tools.
-- E2E tests run on physical iPhones (an iOS `list-devices` entry with kind `"device"`), but replay never auto-binds one, even when no simulator is booted: pass the phone's udid as `device` (CLI `--device`), and only a `connected` phone can run. `pinch`/`rotate` steps fail there like the live tools. On hardware the runner tree is the `describe` tree: same ids and roles, no UIView hierarchy. See `argent-ios-device-interact` for the hardware contract.
+- E2E tests run on physical iPhones (an iOS `list-devices` entry with kind `"device"`), but replay never auto-binds one, even when no simulator is booted: pass the phone's udid as `device` (CLI `--device`), and only a `connected` phone can run. `pinch`/`rotate` steps run there as two-finger gestures, in apps drawn in portrait. On hardware the runner tree is the `describe` tree: same ids and roles, no UIView hierarchy. See `argent-ios-device-interact` for the hardware contract.
 - On capture warnings, raw coordinates, unavailable trees, mistimed transitions, overlays, or replay failures, read [Reliability and recovery](references/reliability-and-recovery.md).
 
 ## Non-negotiable rules

package/skills/argent-ios-device-interact/SKILL.md

@@ -11,10 +11,10 @@ Read this only for a physical iPhone. `argent-device-interact` still applies for
 
 - Observation never changes the screen; mutation may. `describe` and `await-ui-element` fail on a backgrounded target instead of re-fronting it; `await-screen-idle` returns `settled: false` with no reason. The first `describe` within a second of `button home` can still return the old tree; describe again. Gestures and `keyboard` re-front it and return `reactivated: true`; re-describe before the next step.
 - `launch-app`, `open-url` and `restart-app` set the app under automation; `reinstall-app` clears it; a tool-server restart forgets it: launch again.
-- Each tool's description states its own hardware limits (named keys, `gesture-custom` shapes, buttons, edge swipes, tap counts). A gated tool fails with a bare `not supported on ios device`: the fix is in the list below, not in the error.
+- Each tool's description states its own hardware limits (named keys, buttons, edge swipes, tap counts). A gated tool fails with a bare `not supported on ios device`: the fix is in the list below, not in the error.
 
 ## Tools on hardware
 
-- Only these exist: `list-devices`, `launch-app`, `restart-app`, `reinstall-app`, `open-url`, `describe`, `screenshot`, `screenshot-diff`, `gesture-tap`, `gesture-swipe`, `gesture-custom`, `button` (`home`, `volumeUp`, `volumeDown`, `actionButton` on models that have one), `keyboard`, `await-ui-element`, `await-screen-idle`, `run-sequence`, the e2e tools, `stop-simulator-server` and `stop-all-simulator-servers` (session end). Every other device tool fails with `not supported on ios device`.
-- No two-finger gestures, `rotate`, `shake`, `paste`, `settings-permissions`, screen recording, `debugger-*`, `react-profiler-*`, `native-profiler-*`, `native-*`, `boot-device`: drive the app's own zoom and rotate UI with taps and drags, move the phone by hand, type with `keyboard`, change permissions in the phone's Settings, and debug, profile or record on a simulator.
+- Only these exist: `list-devices`, `launch-app`, `restart-app`, `reinstall-app`, `open-url`, `describe`, `screenshot`, `screenshot-diff`, `gesture-tap`, `gesture-swipe`, `gesture-custom`, `gesture-pinch`, `gesture-rotate`, `button` (`home`, `volumeUp`, `volumeDown`, `actionButton` on models that have one), `keyboard`, `await-ui-element`, `await-screen-idle`, `run-sequence`, the e2e tools, `stop-simulator-server` and `stop-all-simulator-servers` (session end). Every other device tool fails with `not supported on ios device`.
+- No `rotate` (the orientation tool), `shake`, `paste`, `settings-permissions`, screen recording, `debugger-*`, `react-profiler-*`, `native-profiler-*`, `native-*`, `boot-device`: move the phone by hand, type with `keyboard`, change permissions in the phone's Settings, and debug, profile or record on a simulator.
 - `gesture-swipe`: `durationMs` sets drag speed, not time; `momentum:false` only rests 300 ms at the end, no damping. `open-url` https lands in Safari, never in the app that owns the link: pass `bundleId`.

package/skills/argent-qa-e2e/SKILL.md

@@ -11,7 +11,7 @@ Load `argent-create-e2e` as the authoring engine. Follow its required references
 
 **Apple TV and Android TV are out of scope.** The runner does not reject touch directives there, so they fail at the gesture layer instead of with authoring guidance. Use `argent-tv-interact` and report the limitation.
 
-**Physical iPhones** run QA e2e tests, with three hardware limits: replay never auto-binds a phone, so pass its udid as `device` (CLI `--device`) and keep it `connected`; `pinch`/`rotate` steps fail there like the live tools, so drive the app's own zoom UI instead; the runner tree is the `describe` tree (same ids and roles), so a selector authored on a simulator can miss there. Read `argent-ios-device-interact` for the app-scoped contract before recording.
+**Physical iPhones** run QA e2e tests, with two hardware limits: replay never auto-binds a phone, so pass its udid as `device` (CLI `--device`) and keep it `connected`; the runner tree is the `describe` tree (same ids and roles), so a selector authored on a simulator can miss there. `pinch`/`rotate` steps run as two-finger gestures, in apps drawn in portrait. Read `argent-ios-device-interact` for the app-scoped contract before recording.
 
 ## Definition of done