agent-device 0.21.13 → 0.21.15

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

@@ -11,8 +11,8 @@ extension RunnerTests {
   private func executeSnapshotDispatchedOnce(command: Command) throws -> Response {
     let preparation: SnapshotCommandPreparation = try runMainThreadWork(
       "command_preparation",
-      timeout: mainThreadExecutionTimeout,
-      timeoutError: mainThreadExecutionTimeoutError
+      timeout: Self.mainThreadExecutionTimeout,
+      timeoutError: Self.mainThreadExecutionTimeoutError
     ) { () -> SnapshotCommandPreparation in
       switch try self.prepareActiveCommandContextSafely(command: command, routeToSpringboard: false) {
       case .response(let response):
@@ -36,6 +36,7 @@ extension RunnerTests {
     }
   }
 
+  @MainActor
   private func prepareActiveCommandContextSafely(
     command: Command,
     routeToSpringboard: Bool
@@ -125,9 +126,9 @@ extension RunnerTests {
       try runMainThreadWork(
         "post_snapshot_delay_mark",
         timeout: 1,
-        timeoutError: mainThreadExecutionTimeoutError
+        timeoutError: Self.mainThreadExecutionTimeoutError
       ) {
-        self.needsPostSnapshotInteractionDelay = true
+        self.mainOwned.needsPostSnapshotInteractionDelay = true
       }
     } catch {
       NSLog("AGENT_DEVICE_RUNNER_POST_SNAPSHOT_DELAY_MARK_FAILED=%@", String(describing: error))

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

@@ -24,11 +24,11 @@ enum SnapshotCapturePhase: Equatable {
 }
 
 struct SnapshotPhaseTimer {
-  private let now: () -> Date
+  private let now: @Sendable () -> Date
   private var acquisitionSeconds: TimeInterval = 0
   private var presentationSeconds: TimeInterval = 0
 
-  init(now: @escaping () -> Date = { Date() }) {
+  init(now: @escaping @Sendable () -> Date = { Date() }) {
     self.now = now
   }
 

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

@@ -14,15 +14,12 @@ enum RunnerAccessibilityHealth: String, Equatable {
 
 enum SynthesizedKeyboardPolicy: String, Equatable, Hashable {
   case never
-  case whenAccessibilityHealthy
   case requiredWhenAvailable
 
   func allowsProbe(accessibilityHealth: RunnerAccessibilityHealth) -> Bool {
     switch self {
     case .never:
       return false
-    case .whenAccessibilityHealthy:
-      return accessibilityHealth == .healthy
     case .requiredWhenAvailable:
       return accessibilityHealth != .unavailable
     }
@@ -63,7 +60,6 @@ struct SynthesizedCoordinateContext {
 
   let resolvedWindow: XCUIElement
   let keyboardPolicy: SynthesizedKeyboardPolicy
-  let fallbackPolicy: SynthesizedFallbackPolicy
   let accessibilityHealth: RunnerAccessibilityHealth
 
   func withReferenceFrame(_ frame: CGRect) -> SynthesizedCoordinateContext {
@@ -71,15 +67,10 @@ struct SynthesizedCoordinateContext {
       referenceFrame: frame,
       resolvedWindow: resolvedWindow,
       keyboardPolicy: keyboardPolicy,
-      fallbackPolicy: fallbackPolicy,
       accessibilityHealth: accessibilityHealth
     )
   }
 
-  var allowsXCTestCoordinateFallback: Bool {
-    fallbackPolicy.allowsXCTestCoordinateFallback(accessibilityHealth: accessibilityHealth)
-  }
-
   var allowsKeyboardProbe: Bool {
     keyboardPolicy.allowsProbe(accessibilityHealth: accessibilityHealth)
   }
@@ -115,24 +106,64 @@ func shouldProbeCoordinateTapTextInput(xCTestChannelPenalized: Bool) -> Bool {
   !xCTestChannelPenalized
 }
 
-func sequenceHasSynthesizedCoordinateStep(_ steps: [SequenceStep]) -> Bool {
-  steps.contains { step in
-    step.synthesized == true && step.kind == "tap"
-  }
+
+func synthesizedPolicyKind(forSequenceStep step: SequenceStep) -> SynthesizedGesturePolicyKind? {
+  step.synthesized == true && step.kind == "tap" ? .coordinateTap : nil
+}
+
+
+enum SynthesizedGestureAttempt {
+  case performed(timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double))
+
+  case xctestFallback(message: String, hint: String?)
+
+  case refused(
+    timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double),
+    message: String,
+    hint: String?
+  )
 }
 
 extension RunnerTests {
+  @MainActor
   func synthesizedSequenceCoordinateContext(
     steps: [SequenceStep],
     app: XCUIApplication
   ) -> SynthesizedCoordinateContext? {
-    guard sequenceHasSynthesizedCoordinateStep(steps) else { return nil }
-    return synthesizedCoordinateContext(
-      app: app,
-      policy: synthesizedGesturePolicy(.synthesizedDrag)
+    guard let kind = steps.lazy.compactMap(synthesizedPolicyKind(forSequenceStep:)).first else {
+      return nil
+    }
+    return synthesizedCoordinateContext(app: app, policy: synthesizedGesturePolicy(kind))
+  }
+
+
+
+  @MainActor
+  func performSynthesizedGesture(
+    _ app: XCUIApplication,
+    kind: SynthesizedGesturePolicyKind,
+    context: SynthesizedCoordinateContext?,
+    synthesize: () -> RunnerInteractionOutcome
+  ) -> SynthesizedGestureAttempt {
+    let (timing, outcome) = performGesture(app, idleTimeout: false, synthesize)
+    guard case .unsupported(let message, let hint) = outcome else {
+      logSynthesizedGesturePolicyDecision(kind: kind, context: context, fallbackAttempted: false)
+      return .performed(timing: timing)
+    }
+    let fallbackAllowed = synthesizedGesturePolicy(kind).fallbackPolicy.allowsXCTestCoordinateFallback(
+      accessibilityHealth: context?.accessibilityHealth ?? mainOwned.accessibilityHealth
+    )
+    logSynthesizedGesturePolicyDecision(
+      kind: kind,
+      context: context,
+      fallbackAttempted: fallbackAllowed
     )
+    return fallbackAllowed
+      ? .xctestFallback(message: message, hint: hint)
+      : .refused(timing: timing, message: message, hint: hint)
   }
 
+  @MainActor
   func logSynthesizedGesturePolicyDecision(
     kind: SynthesizedGesturePolicyKind,
     context: SynthesizedCoordinateContext?,
@@ -162,11 +193,12 @@ extension RunnerTests {
       return "AGENT_DEVICE_RUNNER_SYNTHESIZED_GESTURE_POLICY kind=\(kind.rawValue)"
         + " context=unavailable fallbackAttempted=\(fallbackAttempted)"
     }
+    let fallbackPolicy = synthesizedGesturePolicy(kind).fallbackPolicy
     return "AGENT_DEVICE_RUNNER_SYNTHESIZED_GESTURE_POLICY kind=\(kind.rawValue)"
       + " axHealth=\(context.accessibilityHealth.rawValue) frameSource=window"
       + " keyboardPolicy=\(context.keyboardPolicy.rawValue)"
-      + " fallbackPolicy=\(context.fallbackPolicy.rawValue)"
-      + " fallbackAllowed=\(context.allowsXCTestCoordinateFallback)"
+      + " fallbackPolicy=\(fallbackPolicy.rawValue)"
+      + " fallbackAllowed=\(fallbackPolicy.allowsXCTestCoordinateFallback(accessibilityHealth: context.accessibilityHealth))"
       + " fallbackAttempted=\(fallbackAttempted)"
   }
 }

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

@@ -2,6 +2,7 @@ import XCTest
 import AgentDeviceSnapshotPresentation
 
 extension RunnerTests {
+  @MainActor
   func synthesizedDragAt(
     app: XCUIApplication,
     x: Double,
@@ -89,6 +90,7 @@ extension RunnerTests {
 #endif
   }
 
+  @MainActor
   func synthesizedTapAt(
     app: XCUIApplication,
     x: Double,
@@ -276,6 +278,7 @@ extension RunnerTests {
 #endif
   }
 
+  @MainActor
   func axFreeSynthesizedDragPlan(
     app: XCUIApplication,
     x: Double,
@@ -364,12 +367,13 @@ extension RunnerTests {
     )
   }
 
+  @MainActor
   func synthesizedCoordinateContext(
     app: XCUIApplication,
     policy: SynthesizedGesturePolicy
   ) -> SynthesizedCoordinateContext? {
 #if os(iOS)
-    let health = runnerAccessibilityHealth
+    let health = mainOwned.accessibilityHealth
     let resolved = resolveRunnerWindow(app: app)
     guard let window = resolved.window else {
       return nil
@@ -384,7 +388,6 @@ extension RunnerTests {
       referenceFrame: referenceFrame,
       resolvedWindow: window,
       keyboardPolicy: policy.keyboardPolicy,
-      fallbackPolicy: policy.fallbackPolicy,
       accessibilityHealth: health
     )
 #else

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

@@ -82,11 +82,11 @@ extension RunnerTests {
     text: String,
     delaySeconds: Double
   ) -> [SynthesizedReplacementStep] {
-    let characters = Array(text)
-    guard delaySeconds > 0, characters.count > 1 else {
+    guard synthesizedReplacementIsSpaced(characterCount: text.count, delaySeconds: delaySeconds)
+    else {
       return [SynthesizedReplacementStep(text: text, replacesExistingText: true)]
     }
-    return characters.enumerated().map { index, character in
+    return Array(text).enumerated().map { index, character in
       SynthesizedReplacementStep(
         text: String(character),
         replacesExistingText: index == 0
@@ -94,11 +94,86 @@ extension RunnerTests {
     }
   }
 
+
+
+  static func synthesizedReplacementIsSpaced(characterCount: Int, delaySeconds: Double) -> Bool {
+    delaySeconds > 0 && characterCount > 1
+  }
+
+
+
+
+  enum SynthesizedDeliveryBudget {
+
+    static var characterInterval: TimeInterval {
+      1.0 / Double(RunnerSynthesizedTextEntry.typingSpeedCharactersPerSecond())
+    }
+
+
+
+
+
+
+    static func projectedSeconds(
+      textLength: Int,
+      delaySeconds: TimeInterval,
+      typeWarmup: Bool = false
+    ) -> TimeInterval {
+      let spaced = synthesizedReplacementIsSpaced(characterCount: textLength, delaySeconds: delaySeconds)
+      let warmupSplit = typeWarmup && textLength > 1 && !spaced
+      let calls = spaced ? textLength : (warmupSplit ? 2 : 1)
+      return Double(textLength) * characterInterval
+        + Double(calls) * TextEntryTiming.synthesizeCallOverhead
+        + Double(calls - 1) * delaySeconds
+        + (warmupSplit ? TextEntryTiming.pollInterval : 0)
+    }
+
+    static func exceeds(
+      textLength: Int,
+      delaySeconds: TimeInterval,
+      typeWarmup: Bool = false
+    ) -> Bool {
+      projectedSeconds(textLength: textLength, delaySeconds: delaySeconds, typeWarmup: typeWarmup)
+        > TextEntryTiming.synthesizedDeliveryCeiling
+    }
+
+
+    static func maxTextLength(delaySeconds: TimeInterval) -> Int {
+      var length = 1
+      while !exceeds(textLength: length + 1, delaySeconds: delaySeconds) {
+        length += 1
+      }
+      return length
+    }
+  }
+
+  @MainActor
   func runSynthesizedReplacementRoute(
     _ request: SynthesizedReplacementRequest
   ) -> SynthesizedReplacementRouteOutcome {
 #if os(iOS)
     NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=synthesized-first-responder-replacement")
+    if SynthesizedDeliveryBudget.exceeds(
+      textLength: request.text.count,
+      delaySeconds: request.delaySeconds
+    ) {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=synthesized-first-responder-replacement "
+          + "reason=delivery-budget-refused chars=%d budgetChars=%d",
+        request.text.count,
+        SynthesizedDeliveryBudget.maxTextLength(delaySeconds: request.delaySeconds)
+      )
+      return .completed(
+        TextEntryResult(
+          verified: nil,
+          repaired: false,
+          expectedText: request.text,
+          observedText: nil,
+          textEntryRoute: "synthesized-first-responder-replacement",
+          failure: .synthesisBudgetExceeded
+        )
+      )
+    }
     let steps = Self.synthesizedReplacementSteps(
       text: request.text,
       delaySeconds: request.delaySeconds
@@ -270,11 +345,4 @@ extension RunnerTests {
   ) -> Bool {
     repairMode == .replacement && hasX && hasY && xCTestChannelPenalized
   }
-
-  static func shouldFallbackFromSynthesizedTextEntryFocus(
-    _ outcome: RunnerInteractionOutcome
-  ) -> Bool {
-    if case .unsupported = outcome { return true }
-    return false
-  }
 }

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

@@ -8,6 +8,7 @@ extension RunnerTests {
     case notFocused = "TEXT_INPUT_NOT_FOCUSED"
     case synthesisUnavailable = "TEXT_INPUT_SYNTHESIS_UNAVAILABLE"
     case commitNotObserved = "TEXT_INPUT_COMMIT_NOT_OBSERVED"
+    case synthesisBudgetExceeded = "TEXT_INPUT_SYNTHESIS_BUDGET_EXCEEDED"
 
     var message: String {
       switch self {
@@ -17,6 +18,8 @@ extension RunnerTests {
         return "Reliable text synthesis is unavailable while the software keyboard is hidden."
       case .commitNotObserved:
         return "The runner could not confirm the typed text reached the field."
+      case .synthesisBudgetExceeded:
+        return "The text is longer than one runner command can type at this pace."
       }
     }
 
@@ -27,7 +30,13 @@ extension RunnerTests {
       case .synthesisUnavailable:
         return "Show the software keyboard, then retry type."
       case .commitNotObserved:
-        return "The field may hold none, part, or all of the text. Run snapshot -i and inspect the field: if it already matches, continue; otherwise retry fill with the full text quoted and --delay-ms 80. Do not use type, which appends to whatever committed."
+        return "The field may hold none, part, or all of the text. Run snapshot -i and inspect the field: if it already matches, continue; otherwise retry fill with the full text quoted and --delay-ms \(TextEntryTiming.recoveryDelayMilliseconds). Do not use type, which appends to whatever committed."
+      case .synthesisBudgetExceeded:
+        let recoveryDelay = TextEntryTiming.recoveryDelayMilliseconds
+        let recoveryBudget = SynthesizedDeliveryBudget.maxTextLength(
+          delaySeconds: Double(recoveryDelay) / 1000
+        )
+        return "Fill at most \(SynthesizedDeliveryBudget.maxTextLength(delaySeconds: 0)) characters at a time without --delay-ms and append the rest with separate type commands, keeping each command inside that budget. --delay-ms lowers the budget, because each character then gets its own synthesize call and each gap between characters pays the delay: \(recoveryBudget) characters at --delay-ms \(recoveryDelay). A longer timeout does not help: this route is chosen when the accessibility channel is already degraded, and the pace is what makes the text long."
       }
     }
   }
@@ -51,8 +60,29 @@ extension RunnerTests {
     static let synthesizedCommitStallTimeout: TimeInterval = 3.0
 
 
-
     static let synthesizedCommitCeiling: TimeInterval = 10.0
+
+
+    static let synthesizedReplacementFocusAllowance: TimeInterval = 2.0
+
+
+
+
+    static let synthesizedDeliveryCeiling: TimeInterval = RunnerTests.mainThreadExecutionTimeout
+      - synthesizedReplacementFocusAllowance
+      - synthesizedCommitCeiling
+
+
+
+
+
+    static let synthesizedAcknowledgeWindowSeconds: TimeInterval = 0.04
+
+
+
+    static let synthesizeCallOverhead: TimeInterval = 0.15
+
+    static let recoveryDelayMilliseconds = 80
     static let synthesizedCommitPollInterval: TimeInterval = 0.2
   }
 

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

@@ -6,6 +6,7 @@ import XCTest
 
 
 extension RunnerTests {
+  @MainActor
   func rememberTextEntryTap(_ element: XCUIElement?) {
     guard let element, isTextEntryElement(element) else {
       clearRememberedTextEntryTap()
@@ -13,8 +14,8 @@ extension RunnerTests {
     }
     textEntryTapWitness = TextEntryTapWitness(
       element: element,
-      bundleId: currentBundleId,
-      processIdentifier: currentAppProcessIdentifier
+      bundleId: mainOwned.bundleId,
+      processIdentifier: mainOwned.processIdentifier
     )
   }
 
@@ -22,6 +23,7 @@ extension RunnerTests {
     textEntryTapWitness = nil
   }
 
+  @MainActor
   private func rememberedTextEntryTarget() -> TextEntryTarget? {
     guard let witness = textEntryTapWitness else {
       return nil
@@ -30,8 +32,8 @@ extension RunnerTests {
 
     clearRememberedTextEntryTap()
     guard witness.matches(
-      bundleId: currentBundleId,
-      processIdentifier: currentAppProcessIdentifier
+      bundleId: mainOwned.bundleId,
+      processIdentifier: mainOwned.processIdentifier
     ) else {
       return nil
     }
@@ -80,6 +82,7 @@ extension RunnerTests {
 #endif
   }
 
+  @MainActor
   func focusTextInputForTextEntry(app: XCUIApplication, x: Double?, y: Double?) -> TextEntryTarget {
     guard let x, let y else {
       let softwareKeyboardVisible = isKeyboardVisible(app: app)

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

@@ -3,6 +3,7 @@ import XCTest
 
 
 extension RunnerTests {
+  @MainActor
   func typeTextReliably(
     app: XCUIApplication,
     target: TextEntryTarget,
@@ -162,6 +163,28 @@ extension RunnerTests {
         return (currentTarget, nil)
       } else if activeTarget.prefersFocusedElement && isKeyboardVisible(app: app) {
 #if os(iOS)
+
+
+
+
+
+
+
+
+        if SynthesizedDeliveryBudget.exceeds(
+          textLength: text.count,
+          delaySeconds: delaySeconds,
+          typeWarmup: repairMode != .none
+        ) {
+          textEntryRoute = "xctest-application-fallback"
+          NSLog(
+            "AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=xctest-application-fallback "
+              + "reason=delivery-budget chars=%d",
+            value.count
+          )
+          app.typeText(value)
+          return (resolveTextEntryElement(app: app, target: activeTarget), nil)
+        }
         textEntryRoute = "synthesized-first-responder"
         NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=synthesized-first-responder")
         let action = synthesizer.enterText(

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

@@ -33,11 +33,7 @@ extension RunnerTests {
       let combined = buffer + data
       if let body = self.parseRequest(data: combined) {
         self.handleRequestBody(body) { [weak self] result in
-          self?.sendResponse(result.data, over: connection) { [weak self] in
-            if result.shouldFinish {
-              self?.finish()
-            }
-          }
+          self?.sendResult(result, over: connection)
         }
       } else {
         self.receiveRequest(connection: connection, buffer: combined)
@@ -45,10 +41,21 @@ extension RunnerTests {
     }
   }
 
+  private func sendResult(
+    _ result: (data: Data, shouldFinish: Bool),
+    over connection: NWConnection
+  ) {
+    sendResponse(result.data, over: connection) { [weak self] in
+      if result.shouldFinish {
+        self?.finish()
+      }
+    }
+  }
+
   private func sendResponse(
     _ response: Data,
     over connection: NWConnection,
-    afterSend: @escaping () -> Void = {}
+    afterSend: @escaping @Sendable () -> Void = {}
   ) {
     connection.send(content: response, isComplete: true, completion: .contentProcessed { error in
       if let error {
@@ -89,7 +96,7 @@ extension RunnerTests {
 
   private func handleRequestBody(
     _ body: Data,
-    completion: @escaping ((data: Data, shouldFinish: Bool)) -> Void
+    completion: @escaping @Sendable ((data: Data, shouldFinish: Bool)) -> Void
   ) {
     guard String(data: body, encoding: .utf8) != nil else {
       completion((
@@ -187,7 +194,7 @@ extension RunnerTests {
 
   func enqueueAccepted(
     command: Command,
-    completion: @escaping (Result<Response, Error>) -> Void
+    completion: @escaping @Sendable (Result<Response, Error>) -> Void
   ) {
     commandJournal.accept(command: command)
     commandExecutionQueue.async {
@@ -202,7 +209,7 @@ extension RunnerTests {
 
   func attachToInFlightCommandIfNeeded(
     command: Command,
-    completion: @escaping ((data: Data, shouldFinish: Bool)) -> Void
+    completion: @escaping @Sendable ((data: Data, shouldFinish: Bool)) -> Void
   ) -> Bool {
     guard let commandId = command.commandId?.trimmedNonEmpty else { return false }
     inFlightCommandLock.lock()
@@ -226,7 +233,7 @@ extension RunnerTests {
     result: (data: Data, shouldFinish: Bool),
     completion: ((data: Data, shouldFinish: Bool)) -> Void
   ) {
-    var waiters: [((data: Data, shouldFinish: Bool)) -> Void] = []
+    var waiters: [@Sendable ((data: Data, shouldFinish: Bool)) -> Void] = []
     if let commandId = command.commandId?.trimmedNonEmpty {
       inFlightCommandLock.lock()
       inFlightCommandIds.remove(commandId)

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

@@ -52,23 +52,22 @@ extension RunnerTests {
   }
 
   func elementHasFocus(_ element: XCUIElement) -> Bool {
-    var focused = false
-    _ = RunnerObjCExceptionCatcher.catchException({
-      if let value = (element as NSObject).value(forKey: "hasFocus") as? Bool {
-        focused = value
-      }
-    })
-    return focused
+    return focusBool(element as NSObject)
   }
 
-  func activateElement(app: XCUIApplication, element: XCUIElement, action: String) -> RunnerInteractionOutcome {
+  func activateElement(
+    app: XCUIApplication,
+    element: XCUIElement,
+    action: String,
+    resolvedFrame: CGRect? = nil
+  ) -> RunnerInteractionOutcome {
     if let outcome = selectFocusedTvElement(app: app, element: element, action: action) {
       return outcome
     }
 #if os(tvOS)
     return performElementTap(element)
 #else
-    let frame = element.frame
+    let frame = resolvedFrame ?? element.frame
     if !frame.isEmpty {
 
 

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

@@ -2,6 +2,7 @@ import XCTest
 import AgentDeviceSnapshotPresentation
 
 extension RunnerTests {
+  @MainActor
   func executeTypeCommand(activeApp: XCUIApplication, command: Command) -> Response {
     guard let text = command.text else {
       return Response(ok: false, error: ErrorPayload(message: "type requires text"))
@@ -18,7 +19,7 @@ extension RunnerTests {
       : nil
     let focusStartedAt = Date()
 #if os(iOS)
-    let xCTestChannelPenalized = isSnapshotXCTestChannelPenalized(bundleId: currentBundleId)
+    let xCTestChannelPenalized = isSnapshotXCTestChannelPenalized(bundleId: mainOwned.bundleId)
     var resolvedCoordinateTarget: TextEntryTarget?
     if Self.shouldUseResolvedCoordinateTextEntryRoute(
       repairMode: textEntryMode,
@@ -31,27 +32,20 @@ extension RunnerTests {
         app: activeApp,
         policy: synthesizedGesturePolicy(policyKind)
       )
-      let (_, outcome) = performGesture(activeApp, idleTimeout: false) {
+      switch performSynthesizedGesture(activeApp, kind: policyKind, context: context, synthesize: {
         synthesizedTapAt(app: activeApp, x: x, y: y, context: context)
-      }
-      if Self.shouldFallbackFromSynthesizedTextEntryFocus(outcome) {
-        logSynthesizedGesturePolicyDecision(
-          kind: policyKind,
-          context: context,
-          fallbackAttempted: true
-        )
-      } else {
-        logSynthesizedGesturePolicyDecision(
-          kind: policyKind,
-          context: context,
-          fallbackAttempted: false
-        )
+      }) {
+      case .performed:
         resolvedCoordinateContext = context
         resolvedCoordinateTarget = TextEntryTarget(
           element: nil,
           refreshPoint: CGPoint(x: x, y: y),
           prefersFocusedElement: false
         )
+      case .xctestFallback:
+        break
+      case .refused(_, let message, let hint):
+        return unsupportedResponse(message: message, hint: hint)
       }
     }
 #else