agent-device 0.21.20 → 0.21.22

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunner/AgentDeviceRunnerApp.m

@@ -66,6 +66,10 @@ int main(int argc, const char *argv[]) {
 @property(nonatomic, assign) NSUInteger firstAlertActions;
 @property(nonatomic, assign) NSUInteger replacementAlertActions;
 @property(nonatomic, strong) UILabel *textEntryWriteBackStatus;
+@property(nonatomic, strong) UILabel *textEntryDigitSlots;
+// Filled from the fixture field's own delegate callbacks so a test can tell that a gesture really
+// took focus from an input that has stopped answering the accessibility query that found it.
+@property(nonatomic, strong) UILabel *textEntryFocusWitness;
 @property(nonatomic, assign) NSUInteger textEntryWriteBacks;
 @property(nonatomic, copy, nullable) NSString *textEntryRenderedValue;
 @property(nonatomic, assign) NSTimeInterval textEntryLastEditTime;
@@ -73,6 +77,7 @@ int main(int argc, const char *argv[]) {
 @property(nonatomic, assign) NSUInteger textEntryBurstEdits;
 @property(nonatomic, assign) NSTimeInterval textEntryBurstMinGap;
 @property(nonatomic, assign) NSTimeInterval textEntryAcknowledgeWindowSeconds;
+@property(nonatomic, strong) NSLayoutConstraint *textEntryFieldTop;
 @property(nonatomic, assign) BOOL alertFixtureStarted;
 @property(nonatomic, strong) NSTimer *alertActivationBusyBackstop;
 @property(nonatomic, strong) NSTimer *alertBannerRepost;
@@ -81,6 +86,17 @@ int main(int argc, const char *argv[]) {
 #if TARGET_OS_IOS
 @interface AgentDeviceRunnerViewController () <UNUserNotificationCenterDelegate>
 @end
+
+// A one-time-code field that announces how many digits it holds instead of the digits, the way
+// React Native OTP inputs set `accessibilityValue` on their hidden text input.
+@interface AgentDeviceDigitCountTextField : UITextField
+@end
+
+@implementation AgentDeviceDigitCountTextField
+- (NSString *)accessibilityValue {
+  return [NSString stringWithFormat:@"%lu of 6 digits", (unsigned long)self.text.length];
+}
+@end
 #endif
 
 @implementation AgentDeviceRunnerViewController
@@ -265,6 +281,11 @@ static NSTimeInterval AgentDeviceTextEntryAcknowledgeWindow(void) {
 // Edits further apart than this belong to different bursts: one runner command's characters arrive
 // well inside it, and two commands are separated by at least a commit-wait poll and a status read.
 static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
+static const NSUInteger AgentDeviceTextEntryAutoSubmitLength = 6;
+
+static const CGFloat AgentDeviceTextEntryFieldTopInset = 24;
+static const CGFloat AgentDeviceTextEntryFieldHeight = 44;
+static const CGFloat AgentDeviceTextEntryNeighbourGap = 16;
 
 - (void)agentDeviceTextEntryDidChange:(UITextField *)textField {
   // A field whose app owns its value, the way a controlled React Native `TextInput` does. A burst
@@ -293,10 +314,56 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
     }
     [self updateTextEntryWriteBackStatus];
   }
+  self.textEntryDigitSlots.text = textField.text;
   if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-disappear-after-input"] &&
       textField.text.length > 0) {
     [textField removeFromSuperview];
   }
+  // An auto-submitting one-time-code field: the last digit navigates away, to a screen whose own
+  // input takes the code field's place or to one without an input. `replace-after-input` is the
+  // same navigation landing before the code is complete.
+  NSArray<NSString *> *arguments = NSProcessInfo.processInfo.arguments;
+  BOOL codeComplete = textField.text.length >= AgentDeviceTextEntryAutoSubmitLength;
+  if (textField.superview == nil) {
+    return;
+  }
+  if ((codeComplete && [arguments containsObject:@"--agent-device-text-entry-auto-submit"]) ||
+      (textField.text.length > 0 && [arguments containsObject:@"--agent-device-text-entry-replace-after-input"])) {
+    UITextField *nextScreenField = [[UITextField alloc] initWithFrame:textField.frame];
+    if (![arguments containsObject:@"--agent-device-text-entry-unnamed-input"]) {
+      nextScreenField.accessibilityIdentifier = @"agent-device-auto-submit-next-screen-input";
+    }
+    nextScreenField.borderStyle = UITextBorderStyleRoundedRect;
+    [textField.superview addSubview:nextScreenField];
+    [textField removeFromSuperview];
+    [nextScreenField becomeFirstResponder];
+  } else if (codeComplete &&
+             [arguments containsObject:@"--agent-device-text-entry-auto-submit-without-successor"]) {
+    [textField removeFromSuperview];
+  }
+}
+
+// Stops answering the element-type query that found it, the moment it takes focus, under
+// `--agent-device-text-entry-unqueryable-on-focus`. #3060's Flutter password field reaches this shape
+// because its two accessibility channels disagree once focused — `TextField` through the legacy
+// attributes, `Other` through the modern ones — and what either channel leaves behind is the same:
+// the tap's element answers the query that resolved it up to the gesture and refuses it after, so a
+// read of it after dispatching records an XCTest failure instead of describing the tap that already
+// landed. The field keeps first-responder, so a test still needs a witness that is not the
+// accessibility tree to tell the gesture landed: `agent-device-text-entry-focus` is a label this
+// method fills in from the field's own delegate callback.
+- (void)agentDeviceTextEntryBecomesUnqueryable:(UITextField *)textField {
+  self.textEntryFocusWitness.text = @"focus";
+  textField.hidden = YES;
+}
+
+// Moves the field up by its own height plus the gap below it when it gains focus, the way keyboard
+// avoidance or a bottom sheet extending above the keyboard does, so the neighbouring field slides
+// into the point the focus tap hit.
+- (void)agentDeviceTextEntryDidBeginEditing:(UITextField *)textField {
+  self.textEntryFieldTop.constant =
+      AgentDeviceTextEntryFieldTopInset - AgentDeviceTextEntryFieldHeight - AgentDeviceTextEntryNeighbourGap;
+  [self.view layoutIfNeeded];
 }
 #endif
 
@@ -339,8 +406,13 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
   }
 
   if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-regression"]) {
-    UITextField *textField = [[UITextField alloc] init];
-    textField.accessibilityIdentifier = @"agent-device-hardware-keyboard-input";
+    BOOL digitCountValue =
+        [NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-digit-count-value"];
+    UITextField *textField =
+        digitCountValue ? [[AgentDeviceDigitCountTextField alloc] init] : [[UITextField alloc] init];
+    if (![NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-unnamed-input"]) {
+      textField.accessibilityIdentifier = @"agent-device-hardware-keyboard-input";
+    }
     textField.borderStyle = UITextBorderStyleRoundedRect;
     // An empty input view keeps the software keyboard down, which is the hardware-keyboard responder
     // these routes are addressed to. `--agent-device-text-entry-soft-keyboard` leaves the real input
@@ -354,12 +426,46 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
         forControlEvents:UIControlEventEditingChanged];
     textField.translatesAutoresizingMaskIntoConstraints = NO;
     [self.view addSubview:textField];
+    self.textEntryFieldTop = [textField.topAnchor constraintEqualToAnchor:label.bottomAnchor
+                                                                 constant:AgentDeviceTextEntryFieldTopInset];
     [NSLayoutConstraint activateConstraints:@[
       [textField.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
-      [textField.topAnchor constraintEqualToAnchor:label.bottomAnchor constant:24],
+      self.textEntryFieldTop,
       [textField.widthAnchor constraintEqualToConstant:240],
-      [textField.heightAnchor constraintEqualToConstant:44],
+      [textField.heightAnchor constraintEqualToConstant:AgentDeviceTextEntryFieldHeight],
     ]];
+    if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-unqueryable-on-focus"]) {
+      self.textEntryFocusWitness = [[UILabel alloc] init];
+      self.textEntryFocusWitness.accessibilityIdentifier = @"agent-device-text-entry-focus";
+      self.textEntryFocusWitness.translatesAutoresizingMaskIntoConstraints = NO;
+      [self.view addSubview:self.textEntryFocusWitness];
+      [NSLayoutConstraint activateConstraints:@[
+        [self.textEntryFocusWitness.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
+        [self.textEntryFocusWitness.topAnchor constraintEqualToAnchor:textField.bottomAnchor constant:24],
+      ]];
+      [textField addTarget:self
+                    action:@selector(agentDeviceTextEntryBecomesUnqueryable:)
+          forControlEvents:UIControlEventEditingDidBegin];
+    }
+    if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-moves-on-focus"]) {
+      textField.text = @"stale";
+      [textField addTarget:self
+                    action:@selector(agentDeviceTextEntryDidBeginEditing:)
+          forControlEvents:UIControlEventEditingDidBegin];
+      UITextField *neighbour = [[UITextField alloc] init];
+      neighbour.accessibilityIdentifier = @"agent-device-text-entry-neighbour";
+      neighbour.borderStyle = UITextBorderStyleRoundedRect;
+      neighbour.text = @"neighbour";
+      neighbour.translatesAutoresizingMaskIntoConstraints = NO;
+      [self.view addSubview:neighbour];
+      [NSLayoutConstraint activateConstraints:@[
+        [neighbour.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
+        [neighbour.topAnchor constraintEqualToAnchor:textField.bottomAnchor
+                                            constant:AgentDeviceTextEntryNeighbourGap],
+        [neighbour.widthAnchor constraintEqualToConstant:240],
+        [neighbour.heightAnchor constraintEqualToConstant:AgentDeviceTextEntryFieldHeight],
+      ]];
+    }
     if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-text-entry-app-owned-value"]) {
       self.textEntryAcknowledgeWindowSeconds = AgentDeviceTextEntryAcknowledgeWindow();
       // Reports how many edits this app rendered and how many writes it had to make because a
@@ -375,6 +481,17 @@ static const NSTimeInterval AgentDeviceTextEntryBurstBreakSeconds = 1.0;
       ]];
       [self updateTextEntryWriteBackStatus];
     }
+    if (digitCountValue) {
+      // The slots an OTP screen renders next to its input: the digits the field really holds.
+      self.textEntryDigitSlots = [[UILabel alloc] init];
+      self.textEntryDigitSlots.accessibilityIdentifier = @"agent-device-text-entry-digit-slots";
+      self.textEntryDigitSlots.translatesAutoresizingMaskIntoConstraints = NO;
+      [self.view addSubview:self.textEntryDigitSlots];
+      [NSLayoutConstraint activateConstraints:@[
+        [self.textEntryDigitSlots.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
+        [self.textEntryDigitSlots.topAnchor constraintEqualToAnchor:textField.bottomAnchor constant:12],
+      ]];
+    }
   }
 
   if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-crowded-screen"]) {

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

@@ -5,6 +5,12 @@ NS_ASSUME_NONNULL_BEGIN
 FOUNDATION_EXPORT NSInteger RunnerControlledScrollFrameCount(double durationMs);
 FOUNDATION_EXPORT double RunnerControlledScrollProgress(double t);
 
+typedef NS_ENUM(NSInteger, RunnerTapSynthesisStatus) {
+  RunnerTapSynthesisStatusSucceeded,
+  RunnerTapSynthesisStatusDeadlineExceeded,
+  RunnerTapSynthesisStatusFailed,
+};
+
 @interface RunnerSynthesizedGesture : NSObject
 
 // `resolvedWindow` is the app window the caller already resolved for the gesture's reference
@@ -26,10 +32,12 @@ FOUNDATION_EXPORT double RunnerControlledScrollProgress(double t);
                                                                y2:(double)y2
                                                         durationMs:(double)durationMs;
 
-+ (NSString * _Nullable)synthesizeTapWithApplication:(id)application
++ (RunnerTapSynthesisStatus)synthesizeTapWithApplication:(id)application
                                       resolvedWindow:(id _Nullable)resolvedWindow
                                                    x:(double)x
-                                                   y:(double)y;
+                                                   y:(double)y
+                                            deadline:(NSDate * _Nullable)deadline
+                                        errorMessage:(NSString * _Nullable * _Nullable)errorMessage;
 
 // Each pointer is an ordered array of { x, y, offsetMs } samples. The first sample
 // starts contact; subsequent samples move it; all pointers lift at their final offset.

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

@@ -75,7 +75,13 @@ static NSString * _Nullable RunnerTrySynthesizeDrag(
   NSString *recordName,
   RunnerDragPointerPathFactory pathFactory
 );
-static NSString * _Nullable RunnerTrySynthesizeTap(id application, id _Nullable resolvedWindow, CGPoint point);
+static RunnerTapSynthesisStatus RunnerTrySynthesizeTap(
+  id application,
+  id _Nullable resolvedWindow,
+  CGPoint point,
+  NSDate * _Nullable deadline,
+  NSString * _Nullable * _Nullable errorMessage
+);
 // 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;
@@ -132,14 +138,20 @@ static id RunnerTapPointerPath(
   }
 }
 
-+ (NSString * _Nullable)synthesizeTapWithApplication:(id)application
++ (RunnerTapSynthesisStatus)synthesizeTapWithApplication:(id)application
                                       resolvedWindow:(id _Nullable)resolvedWindow
                                                    x:(double)x
-                                                   y:(double)y {
+                                                   y:(double)y
+                                            deadline:(NSDate * _Nullable)deadline
+                                        errorMessage:(NSString * _Nullable * _Nullable)errorMessage {
+  if (errorMessage != NULL) *errorMessage = nil;
   @try {
-    return RunnerTrySynthesizeTap(application, resolvedWindow, CGPointMake(x, y));
+    return RunnerTrySynthesizeTap(application, resolvedWindow, CGPointMake(x, y), deadline, errorMessage);
   } @catch (NSException *exception) {
-    return RunnerFormatXCTestException(exception, @"private XCTest event synthesis failed");
+    if (errorMessage != NULL) {
+      *errorMessage = RunnerFormatXCTestException(exception, @"private XCTest event synthesis failed");
+    }
+    return RunnerTapSynthesisStatusFailed;
   }
 }
 
@@ -227,7 +239,13 @@ static NSString * _Nullable RunnerTrySynthesizeDrag(
   return RunnerSynthesizeEventRecord(&bridge, record);
 }
 
-static NSString * _Nullable RunnerTrySynthesizeTap(id application, id _Nullable resolvedWindow, CGPoint point) {
+static RunnerTapSynthesisStatus RunnerTrySynthesizeTap(
+  id application,
+  id _Nullable resolvedWindow,
+  CGPoint point,
+  NSDate * _Nullable deadline,
+  NSString * _Nullable * _Nullable errorMessage
+) {
   RunnerGestureEventBridge bridge;
   id record = nil;
   NSString *error = RunnerCreateEventRecord(
@@ -237,14 +255,23 @@ static NSString * _Nullable RunnerTrySynthesizeTap(id application, id _Nullable
     &bridge,
     &record
   );
-  if (error != nil) return error;
+  if (error != nil) {
+    if (errorMessage != NULL) *errorMessage = error;
+    return RunnerTapSynthesisStatusFailed;
+  }
 
   id path = RunnerTapPointerPath(&bridge, point);
   if (path == nil) {
-    return @"private XCTest event synthesis failed: could not create pointer path";
+    if (errorMessage != NULL) *errorMessage = @"private XCTest event synthesis failed: could not create pointer path";
+    return RunnerTapSynthesisStatusFailed;
   }
   ((RunnerMsgSendAddPath)objc_msgSend)(record, bridge.core.addPathSelector, path);
-  return RunnerSynthesizeEventRecord(&bridge, record);
+  if (deadline != nil && deadline.timeIntervalSinceNow <= 0) {
+    return RunnerTapSynthesisStatusDeadlineExceeded;
+  }
+  error = RunnerSynthesizeEventRecord(&bridge, record);
+  if (errorMessage != NULL) *errorMessage = error;
+  return error == nil ? RunnerTapSynthesisStatusSucceeded : RunnerTapSynthesisStatusFailed;
 }
 
 static NSString * _Nullable RunnerResolveGestureEventBridge(

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

@@ -138,12 +138,40 @@ extension RunnerTests {
 #if !os(tvOS)
         guard !frame.isEmpty else { return }
 #endif
+#if os(iOS)
+        let postEventWaitSelector = NSSelectorFromString("_waitForQuiescenceAsPreEvent:")
+        guard alert.ownerApp.responds(to: postEventWaitSelector) else {
+          outcome = .unsupported(
+            message: "alert activation could not wait for post-event quiescence",
+            hint: "Inspect the current alert before deciding whether to act again."
+          )
+          return
+        }
+        switch synthesizedTapAt(app: alert.ownerApp, x: frame.midX, y: frame.midY, deadline: deadline) {
+        case .performed?:
+          typealias WaitForQuiescence = @convention(c) (NSObject, Selector, Bool) -> Void
+          let waitForQuiescence = unsafeBitCast(
+            alert.ownerApp.method(for: postEventWaitSelector),
+            to: WaitForQuiescence.self
+          )
+          waitForQuiescence(alert.ownerApp, postEventWaitSelector, false)
+          outcome = .performed
+        case .unsupported(let message, _)?:
+          outcome = .unsupported(
+            message: message,
+            hint: "Inspect the current alert before deciding whether to act again."
+          )
+        case nil:
+          break
+        }
+#else
         outcome = activateElement(
           app: alert.ownerApp,
           element: button,
           action: "alert \(action)",
           resolvedFrame: frame
         )
+#endif
       }
     }
     return outcome

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

@@ -470,6 +470,13 @@ struct DataPayload: Codable {
   var keyboardMinY: Double?
   var maestroNonHittableCoordinateFallbackUsed: Bool?
   var textEntryRoute: String?
+
+
+  var verification: String?
+  var requested: String?
+  var before: String?
+  var after: String?
+  var target: TextEntryVerificationTargetPayload?
   var runnerFatal: Bool?
   var runnerFatalReason: String?
 
@@ -487,6 +494,26 @@ struct DataPayload: Codable {
 }
 
 
+struct TextEntryVerificationTargetPayload: Codable, Equatable {
+  let resourceId: String?
+  let className: String?
+  let packageName: String?
+  let rect: SnapshotRect
+
+  enum CodingKeys: String, CodingKey {
+    case resourceId, className, packageName, rect
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(resourceId, forKey: .resourceId)
+    try container.encode(className, forKey: .className)
+    try container.encode(packageName, forKey: .packageName)
+    try container.encode(rect, forKey: .rect)
+  }
+}
+
+
 
 
 

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

@@ -68,6 +68,7 @@ extension RunnerTests {
 
 
 
+
   func awaitSynthesizedReplacementCommit(
     app: XCUIApplication,
     target: TextEntryTarget,
@@ -82,6 +83,7 @@ extension RunnerTests {
     let outcome = Self.awaitSynthesizedReplacementCommitOutcome(
       expectedText: expectedText,
       placeholder: ingredients.placeholder,
+      fieldIsSecure: ingredients.fieldIsSecure,
       now: { Date() },
       observe: ingredients.observe,
       waitForNextObservation: ingredients.waitForNextObservation
@@ -132,13 +134,16 @@ extension RunnerTests {
     expectedText: String
   ) -> (
     placeholder: String?,
+    fieldIsSecure: Bool,
     observe: () -> String?,
     waitForNextObservation: () -> Void
   ) {
-    let placeholder = resolveTextEntryElement(app: app, target: target)?.placeholderValue
+    let field = resolveTextEntryElement(app: app, target: target)
+    let placeholder = field?.placeholderValue
     let waitStartedAt = Date()
     return (
       placeholder: placeholder,
+      fieldIsSecure: field?.elementType == .secureTextField,
       observe: {
         let observedText = self.editableTextValue(
           for: self.resolveTextEntryElement(app: app, target: target),

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

@@ -143,9 +143,14 @@ extension RunnerTests {
     _ app: XCUIApplication,
     kind: SynthesizedGesturePolicyKind,
     context: SynthesizedCoordinateContext?,
-    synthesize: () -> RunnerInteractionOutcome
+    synthesize: () -> RunnerInteractionOutcome?
   ) -> SynthesizedGestureAttempt {
-    let (timing, outcome) = performGesture(app, idleTimeout: false, synthesize)
+    var outcome: RunnerInteractionOutcome?
+    let timing = measureGesture { outcome = synthesize() }
+    guard let outcome else {
+      logSynthesizedGesturePolicyDecision(kind: kind, context: context, fallbackAttempted: false)
+      return .refused(timing: timing, message: "synthesized gesture deadline expired before dispatch", hint: nil)
+    }
     guard case .unsupported(let message, let hint) = outcome else {
       logSynthesizedGesturePolicyDecision(kind: kind, context: context, fallbackAttempted: false)
       return .performed(timing: timing)

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

@@ -95,8 +95,9 @@ extension RunnerTests {
     app: XCUIApplication,
     x: Double,
     y: Double,
-    context: SynthesizedCoordinateContext? = nil
-  ) -> RunnerInteractionOutcome {
+    context: SynthesizedCoordinateContext? = nil,
+    deadline: Date? = nil
+  ) -> RunnerInteractionOutcome? {
 #if os(iOS)
     guard x.isFinite, y.isFinite else {
       return .unsupported(
@@ -126,18 +127,31 @@ extension RunnerTests {
       referenceFrame: context.referenceFrame,
       orientation: orientation
     )
-    if let message = RunnerSynthesizedGesture.synthesizeTap(
+    var message: NSString?
+    let status = RunnerSynthesizedGesture.synthesizeTap(
       withApplication: app,
       resolvedWindow: context.resolvedWindow,
       x: Double(point.x),
-      y: Double(point.y)
-    ) {
+      y: Double(point.y),
+      deadline: deadline,
+      errorMessage: &message
+    )
+    switch status {
+    case .succeeded:
+      return .performed
+    case .deadlineExceeded:
+      return nil
+    case .failed:
       return .unsupported(
-        message: message,
+        message: message as String? ?? "private XCTest event synthesis failed",
         hint: "Falling back to XCTest coordinate tap may be slower and can still need a healthy accessibility tree."
       )
+    @unknown default:
+      return .unsupported(
+        message: "private XCTest event synthesis returned an unknown status",
+        hint: "Inspect the current app before deciding whether to act again."
+      )
     }
-    return .performed
 #elseif os(tvOS)
     return .unsupported(
       message: "coordinate tap is not supported on tvOS; move focus with swipe or scroll, then select the focused element",

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

@@ -101,8 +101,27 @@ extension RunnerTests {
       var warmsUpField = false
 
 
+
+
+
+
+      static let maxClearPassCount = 4
+
+      static let unreadableClearPassCount = 2
+
+
       var synthesizeCallCount: Int {
-        replacesExistingText ? 2 : 1
+        replacesExistingText ? 2 * Self.maxClearPassCount + 1 : 1
+      }
+
+
+      var keystrokeCount: Int {
+        characterCount + clearReadCount
+      }
+
+
+      var clearReadCount: Int {
+        replacesExistingText ? Self.maxClearPassCount : 0
       }
     }
 
@@ -129,8 +148,9 @@ extension RunnerTests {
     var seconds: TimeInterval {
       steps.reduce(0) { total, step in
         total
-          + Double(step.characterCount) * TextEntryTiming.synthesizedCharacterInterval
+          + Double(step.keystrokeCount) * TextEntryTiming.synthesizedCharacterInterval
           + Double(step.synthesizeCallCount) * TextEntryTiming.synthesizeCallOverhead
+          + Double(step.clearReadCount) * TextEntryTiming.synthesizedClearReadAllowance
           + step.pauseAfterSeconds
       }
     }
@@ -226,6 +246,48 @@ extension RunnerTests {
     case stop
   }
 
+
+  enum ClearedFieldRead: Equatable {
+    case text(String)
+
+    case unreadable
+
+    case unavailable
+  }
+
+
+  enum SynthesizedClearOutcome: Equatable {
+    case cleared
+
+    case unverified
+
+    case notCleared
+
+    case stopped
+  }
+
+
+
+  static func clearForSynthesizedReplacement(
+    clearOnce: () -> SynthesizedStepDispatch,
+    read: () -> ClearedFieldRead
+  ) -> SynthesizedClearOutcome {
+    for pass in 1...SynthesizedTextPlan.Step.maxClearPassCount {
+      guard clearOnce() == .posted else { return .stopped }
+      switch read() {
+      case .text(let value) where value.isEmpty:
+        return .cleared
+      case .text:
+        continue
+      case .unreadable:
+        if pass >= SynthesizedTextPlan.Step.unreadableClearPassCount { return .unverified }
+      case .unavailable:
+        return .notCleared
+      }
+    }
+    return .notCleared
+  }
+
   struct SynthesizedPlanRun {
     let postedCharacterCount: Int
 
@@ -298,32 +360,68 @@ extension RunnerTests {
         )
       )
     }
+    var clearOutcome: SynthesizedClearOutcome?
 
 
     let synthesisAvailable = runSynthesizedTextPlan(
       plan,
       text: request.text,
       post: { slice, step in
-        switch request.synthesizer.enterText(
-          app: request.app,
-          text: slice,
-          replacingExistingText: step.replacesExistingText
-        ) {
-        case .continueTyping:
-          return .posted
-        case .fallback:
-          return .stop
-        case .raise(let message):
-          NSException(
-            name: NSExceptionName.internalInconsistencyException,
-            reason: message ?? "private XCTest text synthesis failed"
-          ).raise()
-          return .stop
+        func enter(_ text: String, replacingExistingText: Bool) -> SynthesizedStepDispatch {
+          switch request.synthesizer.enterText(
+            app: request.app,
+            text: text,
+            replacingExistingText: replacingExistingText
+          ) {
+          case .continueTyping:
+            return .posted
+          case .fallback:
+            return .stop
+          case .raise(let message):
+            NSException(
+              name: NSExceptionName.internalInconsistencyException,
+              reason: message ?? "private XCTest text synthesis failed"
+            ).raise()
+            return .stop
+          }
+        }
+        if step.replacesExistingText {
+          var passes = 0
+          let outcome = Self.clearForSynthesizedReplacement(
+            clearOnce: {
+              passes += 1
+              return enter(XCUIKeyboardKey.delete.rawValue, replacingExistingText: true)
+            },
+            read: { self.clearedFieldRead(app: request.app, target: request.target) }
+          )
+          clearOutcome = outcome
+          NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_CLEAR passes=%d outcome=%@", passes, String(describing: outcome))
+          guard outcome == .cleared || outcome == .unverified else { return .stop }
         }
+        return enter(slice, replacingExistingText: false)
       },
 
       waitAfterWarmupCharacter: { _ in }
     )
+    if clearOutcome == .notCleared {
+      logTextEntryPhase(
+        commandId: request.commandId,
+        phase: "total",
+        startedAt: request.startedAt,
+        chars: request.text.count,
+        mode: .replacement
+      )
+      return .completed(
+        TextEntryResult(
+          verified: nil,
+          repaired: false,
+          expectedText: request.text,
+          observedText: nil,
+          textEntryRoute: "synthesized-first-responder-replacement",
+          failure: .clearNotObserved
+        )
+      )
+    }
     if synthesisAvailable.stoppedEarly {
       NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=verified-fallback reason=synthesis-unavailable")
       guard let point = request.target.refreshPoint else { return .notApplicable }
@@ -432,6 +530,7 @@ extension RunnerTests {
   static func awaitSynthesizedReplacementCommitOutcome(
     expectedText: String,
     placeholder: String?,
+    fieldIsSecure: Bool = false,
     stallBudget: TimeInterval = TextEntryTiming.synthesizedCommitStallTimeout,
     ceiling: TimeInterval = TextEntryTiming.synthesizedCommitCeiling,
     now: () -> Date = { Date() },
@@ -440,6 +539,11 @@ extension RunnerTests {
   ) -> SynthesizedTextCommitOutcome {
 
 
+    if fieldIsSecure {
+      return .unobservable
+    }
+
+
 
     if Self.textMatchesPlaceholder(expectedText, placeholder: placeholder) {
       return .notObserved