npm - agent-device - Versions diffs - 0.21.12 → 0.21.13 - Mend

agent-device 0.21.12 → 0.21.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (190) hide show

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift CHANGED Viewed

@@ -1,1629 +1,7 @@
 import XCTest
 import AgentDeviceSnapshotPresentation
-extension RunnerTests {
-  private func currentUptimeMs() -> Double {
-    ProcessInfo.processInfo.systemUptime * 1000
-  }
-  private func measureGesture(_ action: () -> Void) -> (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double) {
-    let gestureStartUptimeMs = currentUptimeMs()
-    action()
-    return (gestureStartUptimeMs, currentUptimeMs())
-  }
-  func synthesizedSwipeFallbackHoldDuration(durationMs: Double) -> TimeInterval {
-    min(max((durationMs / 5.0) / 1000.0, 0.016), 0.120)
-  }
-  func coordinateDragHoldDuration() -> TimeInterval {
-    0.050
-  }
-  func unsupportedResponse(for outcome: RunnerInteractionOutcome) -> Response? {
-    switch outcome {
-    case .performed:
-      return nil
-    case .unsupported(let message, let hint):
-      return Response(
-        ok: false,
-        error: ErrorPayload(code: "UNSUPPORTED_OPERATION", message: message, hint: hint)
-      )
-    }
-  }
-  enum GestureFrame {
-    case none
-    case touch(TouchVisualizationFrame?)
-    case drag(DragVisualizationFrame)
-  }
-  struct GestureFallback {
-    let strategy: String
-    let message: String
-    let hint: String?
-  }
-  private func gestureFallback(strategy: String, from outcome: RunnerInteractionOutcome) -> GestureFallback? {
-    switch outcome {
-    case .performed:
-      return nil
-    case .unsupported(let message, let hint):
-      return GestureFallback(strategy: strategy, message: message, hint: hint)
-    }
-  }
-  func performGesture(
-    _ app: XCUIApplication,
-    idleTimeout: Bool = true,
-    _ action: () -> RunnerInteractionOutcome
-  ) -> (timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double), outcome: RunnerInteractionOutcome) {
-    var outcome = RunnerInteractionOutcome.performed
-    let timing = measureGesture {
-      if idleTimeout {
-        withBoundedInteractionIdleTimeoutIfSupported(app, waits: .bothSkipped) {
-          outcome = action()
-        }
-      } else {
-        outcome = action()
-      }
-    }
-    return (timing, outcome)
-  }
-  private func gestureResponse(
-    message: String,
-    timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double),
-    frame: GestureFrame = .none,
-    fallback: GestureFallback? = nil,
-    maestroNonHittableCoordinateFallbackUsed: Bool? = nil
-  ) -> Response {
-    let data: DataPayload
-    switch frame {
-    case .none:
-      data = DataPayload(
-        message: message,
-        gestureStartUptimeMs: timing.gestureStartUptimeMs,
-        gestureEndUptimeMs: timing.gestureEndUptimeMs,
-        gestureFallback: fallback?.strategy,
-        gestureFallbackMessage: fallback?.message,
-        gestureFallbackHint: fallback?.hint,
-        maestroNonHittableCoordinateFallbackUsed: maestroNonHittableCoordinateFallbackUsed
-      )
-    case .touch(let f):
-      data = DataPayload(
-        message: message,
-        gestureStartUptimeMs: timing.gestureStartUptimeMs,
-        gestureEndUptimeMs: timing.gestureEndUptimeMs,
-        x: f?.x,
-        y: f?.y,
-        referenceWidth: f?.referenceWidth,
-        referenceHeight: f?.referenceHeight,
-        gestureFallback: fallback?.strategy,
-        gestureFallbackMessage: fallback?.message,
-        gestureFallbackHint: fallback?.hint,
-        maestroNonHittableCoordinateFallbackUsed: maestroNonHittableCoordinateFallbackUsed
-      )
-    case .drag(let f):
-      data = DataPayload(
-        message: message,
-        gestureStartUptimeMs: timing.gestureStartUptimeMs,
-        gestureEndUptimeMs: timing.gestureEndUptimeMs,
-        x: f.x,
-        y: f.y,
-        x2: f.x2,
-        y2: f.y2,
-        referenceWidth: f.referenceWidth,
-        referenceHeight: f.referenceHeight,
-        gestureFallback: fallback?.strategy,
-        gestureFallbackMessage: fallback?.message,
-        gestureFallbackHint: fallback?.hint
-      )
-    }
-    return Response(ok: true, data: data)
-  }
-  private func canonicalPlannedGestureResponse(_ response: Response) -> Response {
-    guard response.ok, let data = response.data else { return response }
-    return Response(
-      ok: true,
-      data: DataPayload(
-        message: data.message,
-        gestureStartUptimeMs: data.gestureStartUptimeMs,
-        gestureEndUptimeMs: data.gestureEndUptimeMs,
-        gestureFallback: data.gestureFallback,
-        gestureFallbackMessage: data.gestureFallbackMessage,
-        gestureFallbackHint: data.gestureFallbackHint
-      )
-    )
-  }
-  private func plannedGestureResponse(
-    plan: RunnerGesturePlan,
-    timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double),
-    outcome: RunnerInteractionOutcome
-  ) -> Response {
-    if let response = unsupportedResponse(for: outcome) {
-      return response
-    }
-    return gestureResponse(message: plan.intent, timing: timing)
-  }
-  func executeAccepted(command: Command) throws -> Response {
-    commandJournal.start(command: command)
-    pendingTargetActivation = nil
-    do {
-      let response = try executeDispatched(command: command)
-      commandJournal.finish(command: command, response: response)
-      guard let fact = pendingTargetActivation else { return response }
-      pendingTargetActivation = nil
-      return response.stampingTargetActivation(fact)
-    } catch {
-      pendingTargetActivation = nil
-      commandJournal.fail(command: command, error: error)
-      throw error
-    }
-  }
-  func executeStatus(command: Command) -> Response {
-    guard
-      let statusCommandId = command.statusCommandId?.trimmedNonEmpty
-    else {
-      return Response(
-        ok: false,
-        error: ErrorPayload(
-          code: "INVALID_ARGS",
-          message: "status requires statusCommandId",
-          hint: "Set statusCommandId to the commandId of the runner command to inspect."
-        )
-      )
-    }
-    return Response(ok: true, data: commandJournal.status(normalizedCommandId: statusCommandId))
-  }
-  func executeUptime() -> Response {
-    Response(
-      ok: true,
-      data: DataPayload(currentUptimeMs: currentUptimeMs())
-    )
-  }
-  struct ActiveCommandContext {
-    let app: XCUIApplication
-    var systemSurface: SystemSurfaceHost? = nil
-  }
-  enum ActiveCommandPreparation {
-    case response(Response)
-    case context(ActiveCommandContext)
-  }
-  private func runnerBusyResponse(command: Command, abandonedForSeconds: TimeInterval) -> Response {
-    NSLog(
-      "AGENT_DEVICE_RUNNER_BUSY command=%@ commandId=%@ abandonedForSeconds=%.1f",
-      command.command.rawValue,
-      command.commandId ?? "",
-      abandonedForSeconds
-    )
-    return Response(
-      ok: false,
-      error: ErrorPayload(
-        code: "RUNNER_BUSY",
-        message:
-          "The iOS runner is still finishing a previous command that exceeded its execution watchdog (usually an accessibility capture on a heavy or animating screen).",
-        hint:
-          "Wait a few seconds and retry. If snapshots keep failing on this screen, use screenshot as visual truth and interact by coordinates, or navigate to another screen."
-      )
-    )
-  }
-  private func runnerWedgedResponse(command: Command, abandonedForSeconds: TimeInterval) -> Response {
-    NSLog(
-      "AGENT_DEVICE_RUNNER_WEDGED command=%@ commandId=%@ abandonedForSeconds=%.1f",
-      command.command.rawValue,
-      command.commandId ?? "",
-      abandonedForSeconds
-    )
-    return Response(
-      ok: false,
-      error: ErrorPayload(
-        code: "RUNNER_WEDGED",
-        message:
-          "The iOS runner main thread has been stuck in abandoned work for \(Int(abandonedForSeconds)) seconds and cannot recover on its own.",
-        hint:
-          "The runner session will be restarted. Retry the command after the restart; if this screen keeps wedging captures, use screenshot as visual truth and interact by coordinates."
-      )
-    )
-  }
-  private func runnerUnavailableResponse(command: Command) -> Response? {
-    switch currentMainThreadBusyState() {
-    case .idle:
-      return nil
-    case .busy(let abandonedForSeconds):
-      return runnerBusyResponse(command: command, abandonedForSeconds: abandonedForSeconds)
-    case .wedged(let abandonedForSeconds):
-      return runnerWedgedResponse(command: command, abandonedForSeconds: abandonedForSeconds)
-    }
-  }
-  private func executeDispatched(command: Command) throws -> Response {
-    if let unavailable = runnerUnavailableResponse(command: command) {
-      return unavailable
-    }
-    let alertDeadline = command.command == .alert
-      ? Date().addingTimeInterval(Self.alertCommandTimeout(timeoutMs: command.timeoutMs))
-      : nil
-    if Thread.isMainThread {
-      let routeToSpringboard = shouldRouteToSpringboardBlockingSystemModal(command)
-      return try executeOnMainSafely(
-        command: command,
-        alertDeadline: alertDeadline,
-        routeToSpringboard: routeToSpringboard
-      )
-    }
-    let routeToSpringboard = shouldRouteToSpringboardBlockingSystemModal(command)
-    if let unavailable = runnerUnavailableResponse(command: command) {
-      return unavailable
-    }
-    if command.command == .snapshot {
-      return try executeSnapshotDispatched(command: command)
-    }
-    if command.command == .alert, let deadline = alertDeadline {
-      return try runMainThreadWork(
-        "command_execution",
-        timeout: max(0.001, deadline.timeIntervalSinceNow),
-        timeoutError: mainThreadExecutionTimeoutError
-      ) {
-        try self.executeOnMainSafely(
-          command: command,
-          alertDeadline: deadline,
-          routeToSpringboard: routeToSpringboard
-        )
-      }
-    }
-    return try runMainThreadWork(
-      "command_execution",
-      timeout: mainThreadExecutionTimeout,
-      timeoutError: mainThreadExecutionTimeoutError
-    ) {
-      try self.executeOnMainSafely(command: command, routeToSpringboard: routeToSpringboard)
-    }
-  }
-  private func executeOnMainSafely(
-    command: Command,
-    alertDeadline: Date? = nil,
-    routeToSpringboard: Bool
-  ) throws -> Response {
-    var hasRetried = false
-    while true {
-      var response: Response?
-      var swiftError: Error?
-      let failureCountBefore = currentXCTestFailureCount()
-      let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
-        do {
-          response = try self.executeOnMain(
-            command: command,
-            alertDeadline: alertDeadline,
-            routeToSpringboard: routeToSpringboard
-          )
-        } catch {
-          swiftError = error
-        }
-      })
-      if let exceptionMessage {
-        invalidateCachedTarget(reason: "objc_exception")
-        if !hasRetried, shouldRetryException(command, message: exceptionMessage) {
-          NSLog(
-            "AGENT_DEVICE_RUNNER_RETRY command=%@ reason=objc_exception",
-            command.command.rawValue
-          )
-          hasRetried = true
-          sleepFor(retryCooldown)
-          continue
-        }
-        throw NSError(
-          domain: RunnerErrorDomain.exception,
-          code: RunnerErrorCode.objcException,
-          userInfo: [NSLocalizedDescriptionKey: exceptionMessage]
-        )
-      }
-      if let swiftError {
-        throw swiftError
-      }
-      guard let response else {
-        throw NSError(
-          domain: RunnerErrorDomain.general,
-          code: RunnerErrorCode.commandReturnedNoResponse,
-          userInfo: [NSLocalizedDescriptionKey: "command returned no response"]
-        )
-      }
-      if didRecordXCTestFailure(since: failureCountBefore),
-        let failureResponse = xctestRecordedFailureResponse(command: command, response: response)
-      {
-        invalidateCachedTarget(reason: "xctest_recorded_failure")
-        return failureResponse
-      }
-      if !hasRetried, shouldRetryCommand(command), shouldRetryResponse(response) {
-        NSLog(
-          "AGENT_DEVICE_RUNNER_RETRY command=%@ reason=response_unavailable",
-          command.command.rawValue
-        )
-        hasRetried = true
-        invalidateCachedTarget(reason: "response_unavailable")
-        sleepFor(retryCooldown)
-        continue
-      }
-      return response
-    }
-  }
-  private func executeSnapshotDispatched(command: Command) throws -> Response {
-    try executeDispatchedWithRecovery(command: command) {
-      try self.executeSnapshotDispatchedOnce(command: command)
-    }
-  }
-  func executeDispatchedWithRecovery(
-    command: Command,
-    perform: () throws -> Response
-  ) throws -> Response {
-    var hasRetried = false
-    while true {
-      let failureCountBefore = try runMainThreadWork(
-        "recorded_failure_count",
-        timeout: mainThreadExecutionTimeout,
-        timeoutError: mainThreadExecutionTimeoutError
-      ) {
-        self.currentXCTestFailureCount()
-      }
-      let response = try perform()
-      if hasAbandonedMainThreadWork() {
-        NSLog(
-          "AGENT_DEVICE_RUNNER_DISPATCH_RECOVERY_SKIPPED_XCTEST_OCCUPIED command=%@",
-          command.command.rawValue
-        )
-        return response
-      }
-      let recordedFailureResponse = try runMainThreadWork(
-        "recorded_failure_count",
-        timeout: mainThreadExecutionTimeout,
-        timeoutError: mainThreadExecutionTimeoutError
-      ) {
-        self.didRecordXCTestFailure(since: failureCountBefore)
-          ? self.xctestRecordedFailureResponse(command: command, response: response)
-          : nil
-      }
-      if let recordedFailureResponse {
-        try runMainThreadWork(
-          "target_invalidation",
-          timeout: mainThreadExecutionTimeout,
-          timeoutError: mainThreadExecutionTimeoutError
-        ) {
-          self.invalidateCachedTarget(reason: "xctest_recorded_failure")
-        }
-        return recordedFailureResponse
-      }
-      if !hasRetried, shouldRetryCommand(command), shouldRetryResponse(response) {
-        NSLog(
-          "AGENT_DEVICE_RUNNER_RETRY command=%@ reason=response_unavailable",
-          command.command.rawValue
-        )
-        hasRetried = true
-        try runMainThreadWork(
-          "target_invalidation",
-          timeout: mainThreadExecutionTimeout,
-          timeoutError: mainThreadExecutionTimeoutError
-        ) {
-          self.invalidateCachedTarget(reason: "response_unavailable")
-          self.sleepFor(self.retryCooldown)
-        }
-        continue
-      }
-      return response
-    }
-  }
-  private func executeSnapshotDispatchedOnce(command: Command) throws -> Response {
-    let preparation = try runMainThreadWork(
-      "command_preparation",
-      timeout: mainThreadExecutionTimeout,
-      timeoutError: mainThreadExecutionTimeoutError
-    ) {
-      try self.prepareActiveCommandContextSafely(command: command, routeToSpringboard: false)
-    }
-    switch preparation {
-    case .response(let response):
-      return response
-    case .context(let context):
-      return try executeSnapshotPrepared(
-        command: command,
-        activeApp: context.app,
-        systemSurface: context.systemSurface
-      )
-    }
-  }
-  static func presentationOptions(from command: Command) -> PresentationOptions {
-    let customActions = command.customActions ?? false
-    return PresentationOptions(
-      interactiveOnly: command.interactiveOnly ?? false,
-      depth: command.depth,
-      scope: command.scope,
-      raw: command.raw ?? false,
-      preferredBackend: command.preferredBackend
-        ?? (customActions ? SnapshotBackendKind.privateAX.rawValue : nil),
-      customActions: customActions
-    )
-  }
-  private func executeSnapshotPrepared(
-    command: Command,
-    activeApp: XCUIApplication,
-    systemSurface: SystemSurfaceHost? = nil
-  ) throws -> Response {
-    let options = Self.presentationOptions(from: command)
-    do {
-      var payload: DataPayload
-      if options.raw {
-        payload = try snapshotRaw(app: activeApp, options: options)
-      } else {
-        payload = try snapshotFast(app: activeApp, options: options)
-      }
-      if let systemSurface {
-        payload.systemSurface = SystemSurfaceProvenancePayload(
-          bundleId: systemSurface.bundleId,
-          kind: systemSurface.kind.rawValue
-        )
-      }
-      setNeedsPostSnapshotInteractionDelay()
-      return Response(ok: true, data: payload)
-    } catch let failure as SnapshotCaptureFailure {
-      invalidateCachedTargetAfterSnapshotFailure()
-      return Response(
-        ok: false,
-        error: ErrorPayload(
-          code: failure.code,
-          message: failure.message,
-          hint: failure.hint
-        )
-      )
-    }
-  }
-  private func setNeedsPostSnapshotInteractionDelay() {
-    if Thread.isMainThread {
-      needsPostSnapshotInteractionDelay = true
-      return
-    }
-    guard !hasAbandonedMainThreadWork() else {
-      NSLog("AGENT_DEVICE_RUNNER_POST_SNAPSHOT_DELAY_MARK_SKIPPED_XCTEST_OCCUPIED")
-      return
-    }
-    do {
-      try runMainThreadWork(
-        "post_snapshot_delay_mark",
-        timeout: 1,
-        timeoutError: mainThreadExecutionTimeoutError
-      ) {
-        self.needsPostSnapshotInteractionDelay = true
-      }
-    } catch {
-      NSLog("AGENT_DEVICE_RUNNER_POST_SNAPSHOT_DELAY_MARK_FAILED=%@", String(describing: error))
-    }
-  }
-  private func invalidateCachedTargetAfterSnapshotFailure() {
-    if Thread.isMainThread {
-      invalidateCachedTarget(reason: "ax_snapshot_failure")
-      return
-    }
-    guard !hasAbandonedMainThreadWork() else {
-      NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_INVALIDATION_DEFERRED_XCTEST_OCCUPIED")
-      DispatchQueue.main.async {
-        self.invalidateCachedTarget(reason: "ax_snapshot_failure")
-      }
-      return
-    }
-    do {
-      try runMainThreadWork(
-        "target_invalidation",
-        timeout: 1,
-        timeoutError: mainThreadExecutionTimeoutError
-      ) {
-        self.invalidateCachedTarget(reason: "ax_snapshot_failure")
-      }
-    } catch {
-      NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_INVALIDATION_FAILED=%@", String(describing: error))
-    }
-  }
-  private func prepareActiveCommandContextSafely(
-    command: Command,
-    routeToSpringboard: Bool
-  ) throws -> ActiveCommandPreparation {
-    var preparation: ActiveCommandPreparation?
-    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
-      preparation = self.prepareActiveCommandContext(
-        command: command,
-        routeToSpringboard: routeToSpringboard
-      )
-    })
-    if let exceptionMessage {
-      throw NSError(
-        domain: RunnerErrorDomain.exception,
-        code: RunnerErrorCode.objcException,
-        userInfo: [NSLocalizedDescriptionKey: exceptionMessage]
-      )
-    }
-    guard let preparation else {
-      throw NSError(
-        domain: RunnerErrorDomain.general,
-        code: RunnerErrorCode.commandReturnedNoResponse,
-        userInfo: [NSLocalizedDescriptionKey: "snapshot preflight returned no response"]
-      )
-    }
-    return preparation
-  }
-  private func executeOnMain(
-    command: Command,
-    alertDeadline: Date?,
-    routeToSpringboard: Bool
-  ) throws -> Response {
-    let preparation = prepareActiveCommandContext(
-      command: command,
-      routeToSpringboard: routeToSpringboard
-    )
-    let activeApp: XCUIApplication
-    switch preparation {
-    case .response(let response):
-      return response
-    case .context(let context):
-      activeApp = context.app
-    }
-    switch command.command {
-    case .status:
-      return executeStatus(command: command)
-    case .targetReset:
-      return resetTargetAfterExternalRelaunch()
-    case .shutdown:
-      stopRecordingIfNeeded()
-      return Response(ok: true, data: DataPayload(message: "shutdown"))
-    case .recordStart:
-      guard
-        let requestedOutPath = command.outPath?.trimmingCharacters(in: .whitespacesAndNewlines),
-        !requestedOutPath.isEmpty
-      else {
-        return Response(ok: false, error: ErrorPayload(message: "recordStart requires outPath"))
-      }
-      let hasAppBundleId = !(command.appBundleId?
-        .trimmingCharacters(in: .whitespacesAndNewlines)
-        .isEmpty ?? true)
-      guard hasAppBundleId else {
-        return Response(ok: false, error: ErrorPayload(message: "recordStart requires appBundleId"))
-      }
-      if activeRecording != nil {
-        return Response(ok: false, error: ErrorPayload(message: "recording already in progress"))
-      }
-      if let requestedFps = command.fps, (requestedFps < minRecordingFps || requestedFps > maxRecordingFps) {
-        return Response(ok: false, error: ErrorPayload(message: "recordStart fps must be between \(minRecordingFps) and \(maxRecordingFps)"))
-      }
-      do {
-        let resolvedOutPath = resolveRecordingOutPath(requestedOutPath)
-        let fpsLabel = command.fps.map(String.init) ?? String(RunnerTests.defaultRecordingFps)
-        NSLog(
-          "AGENT_DEVICE_RUNNER_RECORD_START requestedOutPath=%@ resolvedOutPath=%@ fps=%@",
-          requestedOutPath,
-          resolvedOutPath,
-          fpsLabel
-        )
-        let recorder = ScreenRecorder(
-          outputPath: resolvedOutPath,
-          fps: command.fps.map { Int32($0) }
-        )
-        try recorder.start { [weak self] in
-          return self?.captureRunnerFrame(app: activeApp)
-        }
-        activeRecording = recorder
-        return Response(ok: true, data: DataPayload(message: "recording started"))
-      } catch {
-        activeRecording = nil
-        return Response(ok: false, error: ErrorPayload(message: "failed to start recording: \(error.localizedDescription)"))
-      }
-    case .recordStop:
-      guard let recorder = activeRecording else {
-        return Response(ok: true, data: DataPayload(message: "recording already stopped"))
-      }
-      do {
-        try recorder.stop()
-        activeRecording = nil
-        return Response(ok: true, data: DataPayload(message: "recording stopped"))
-      } catch {
-        activeRecording = nil
-        return Response(ok: false, error: ErrorPayload(message: "failed to stop recording: \(error.localizedDescription)"))
-      }
-    case .uptime:
-      return executeUptime()
-    case .activate:
-      guard
-        let bundleId = command.appBundleId?.trimmingCharacters(in: .whitespacesAndNewlines),
-        !bundleId.isEmpty
-      else {
-        return Response(ok: false, error: ErrorPayload(message: "activate requires appBundleId"))
-      }
-      return Response(ok: true, data: DataPayload(message: "app activated"))
-    case .terminate:
-      guard
-        let bundleId = command.appBundleId?.trimmingCharacters(in: .whitespacesAndNewlines),
-        !bundleId.isEmpty
-      else {
-        return Response(ok: false, error: ErrorPayload(message: "terminate requires appBundleId"))
-      }
-      XCUIApplication(bundleIdentifier: bundleId).terminate()
-      if currentBundleId == bundleId {
-        invalidateCachedTarget(reason: "target_terminated")
-      }
-      return Response(ok: true, data: DataPayload(message: "app terminated"))
-    default:
-      break
-    }
-    return try executeOnMainPrepared(
-      command: command,
-      activeApp: activeApp,
-      alertDeadline: alertDeadline
-    )
-  }
-  private func prepareActiveCommandContext(
-    command: Command,
-    routeToSpringboard: Bool = false
-  ) -> ActiveCommandPreparation {
-    var activeApp = currentApp ?? app
-    var systemSurface: SystemSurfaceHost? = nil
-    if routeToSpringboard {
-      activeApp = springboard
-    } else if shouldSkipAppActivationPreflight(command) {
-      activeApp = resolveAppWithoutActivation(command: command)
-    } else if let presented = presentedSystemSurfaceHost() {
-      activeApp = presented.app
-      systemSurface = presented.host
-      if isInteractionCommand(command.command) {
-        applyInteractionStabilizationIfNeeded()
-      }
-    } else if !isRunnerLifecycleCommand(command.command) {
-      let normalizedBundleId = command.appBundleId?
-        .trimmingCharacters(in: .whitespacesAndNewlines)
-      let requestedBundleId = (normalizedBundleId?.isEmpty == true) ? nil : normalizedBundleId
-      if let bundleId = requestedBundleId {
-        if currentBundleId != bundleId || currentApp == nil {
-          _ = activateTarget(bundleId: bundleId, reason: "bundle_changed")
-        } else {
-          refreshCachedTargetIfProcessChanged(bundleId: bundleId)
-        }
-      } else {
-        invalidateCachedTarget(reason: "missing_app_bundle")
-      }
-      activeApp = currentApp ?? app
-      if let bundleId = requestedBundleId, targetNeedsActivation(activeApp) {
-        activeApp = activateTarget(bundleId: bundleId, reason: "stale_target")
-      } else if requestedBundleId == nil, targetNeedsActivation(activeApp) {
-        ensureRunnerHostAppActive(reason: "missing_app_bundle")
-        activeApp = app
-      }
-      let skipExistenceWait = canUseFastForegroundAppGuard(
-        activeApp: activeApp,
-        requestedBundleId: requestedBundleId,
-        command: command.command
-      )
-      if !skipExistenceWait && !activeApp.waitForExistence(timeout: appExistenceTimeout) {
-        if let bundleId = requestedBundleId {
-          activeApp = activateTarget(bundleId: bundleId, reason: "missing_after_wait")
-          guard activeApp.waitForExistence(timeout: appExistenceTimeout) else {
-            return .response(Response(ok: false, error: ErrorPayload(message: "app '\(bundleId)' is not available")))
-          }
-        } else {
-          return .response(Response(ok: false, error: ErrorPayload(message: "runner app is not available")))
-        }
-      }
-      if isInteractionCommand(command.command) {
-        if let bundleId = requestedBundleId, activeApp.state != .runningForeground {
-          activeApp = activateTarget(bundleId: bundleId, reason: "interaction_foreground_guard")
-        } else if requestedBundleId == nil, activeApp.state != .runningForeground {
-          ensureRunnerHostAppActive(reason: "interaction_missing_app_bundle")
-          activeApp = app
-        }
-        let skipInteractionExistenceWait = canUseFastForegroundAppGuard(
-          activeApp: activeApp,
-          requestedBundleId: requestedBundleId,
-          command: command.command
-        )
-        if !skipInteractionExistenceWait && !activeApp.waitForExistence(timeout: 2) {
-          if let bundleId = requestedBundleId {
-            return .response(Response(ok: false, error: ErrorPayload(message: "app '\(bundleId)' is not available")))
-          }
-          return .response(Response(ok: false, error: ErrorPayload(message: "runner app is not available")))
-        }
-        applyInteractionStabilizationIfNeeded()
-      }
-    }
-    return .context(ActiveCommandContext(app: activeApp, systemSurface: systemSurface))
-  }
-  private func presentedSystemSurfaceHost() -> (host: SystemSurfaceHost, app: XCUIApplication)? {
-#if os(iOS)
-    for host in SystemSurfaceHostRegistry.hosts {
-      let candidate = XCUIApplication(bundleIdentifier: host.bundleId)
-      if candidate.state == .runningForeground {
-        return (host, candidate)
-      }
-    }
-    return nil
-#else
-    return nil
-#endif
-  }
+extension RunnerTests {
   func executeOnMainPrepared(
     command: Command,
     activeApp: XCUIApplication,
@@ -1634,7 +12,8 @@ extension RunnerTests {
       clearRememberedTextEntryTap()
     }
     switch command.command {
-    case .status, .activate, .terminate, .targetReset, .shutdown, .recordStart, .recordStop, .uptime:
+    case .status, .activate, .terminate, .targetReset, .shutdown, .recordStart, .recordStop, .uptime,
+      .snapshot:
       return Response(
         ok: false,
         error: ErrorPayload(
@@ -1868,9 +247,7 @@ extension RunnerTests {
         x2: x2,
         y2: y2,
         durationMs: defaults.durationMs,
-        synthesized: command.synthesized == true,
-        message: "dragged",
-        synthesizedPolicyKind: .synthesizedDrag
+        message: "dragged"
       )
     case .scroll:
@@ -2052,8 +429,6 @@ extension RunnerTests {
         return Response(ok: false, error: ErrorPayload(message: "readText did not resolve text"))
       }
       return Response(ok: true, data: DataPayload(text: text))
-    case .snapshot:
-      return try executeSnapshotPrepared(command: command, activeApp: activeApp)
     case .screenshot:
 #if os(macOS)
@@ -2119,12 +494,20 @@ extension RunnerTests {
         inlineScreenshot: command.inlineScreenshot == true
       )
 #endif
-    case .back, .backInApp:
-      if tapInAppBackControl(app: activeApp) {
-        let message = command.command == .back ? "back" : "backInApp"
-        return Response(ok: true, data: DataPayload(message: message))
+    case .backInApp:
+      switch tapInAppBackControl(app: activeApp) {
+      case .performed:
+        return Response(ok: true, data: DataPayload(message: "backInApp"))
+      case .unavailable:
+        return Response(
+          ok: false,
+          error: ErrorPayload(message: "in-app back control is not available")
+        )
+      case .unverified(let error):
+        return Response(ok: false, error: error)
       }
-      return Response(ok: false, error: ErrorPayload(message: "in-app back control is not available"))
     case .backSystem:
       if performSystemBackAction(app: activeApp) {
         return Response(ok: true, data: DataPayload(message: "backSystem"))
@@ -2232,10 +615,8 @@ extension RunnerTests {
             x2: last.x,
             y2: last.y,
             durationMs: plan.durationMs,
-            synthesized: true,
             message: plan.intent,
-            synthesizedPolicyKind: .synthesizedDrag,
-            synthesizedProfile: .fastSwipe
+            synthesized: (profile: .fastSwipe, policyKind: .synthesizedDrag)
           )
         )
       case .sampled:
@@ -2254,603 +635,4 @@ extension RunnerTests {
       return executeSequence(command: command, activeApp: activeApp)
     }
   }
-  private func invalidScrollDirectionResponse(commandName: String) -> Response {
-    Response(
-      ok: false,
-      error: ErrorPayload(
-        code: "INVALID_ARGS",
-        message: "\(commandName) requires direction up|down|left|right"
-      )
-    )
-  }
-  private func scrollDurationIsValid(_ durationMs: Double?) -> Bool {
-    guard let durationMs else { return true }
-    return durationMs.isFinite && durationMs >= 0 && durationMs <= 10000
-  }
-  private func invalidScrollDurationResponse(commandName: String) -> Response {
-    return Response(
-      ok: false,
-      error: ErrorPayload(
-        code: "INVALID_ARGS",
-        message: "\(commandName) durationMs must be between 0 and 10000"
-      )
-    )
-  }
-  private func executeScrollDragGesture(
-    activeApp: XCUIApplication,
-    x: Double,
-    y: Double,
-    x2: Double,
-    y2: Double,
-    durationMs: Double,
-    message: String,
-    context: SynthesizedCoordinateContext,
-    releaseBehavior: ScrollReleaseBehavior?
-  ) -> Response {
-#if os(iOS)
-    return executeDragGesture(
-      activeApp: activeApp,
-      x: x,
-      y: y,
-      x2: x2,
-      y2: y2,
-      durationMs: durationMs,
-      synthesized: true,
-      message: message,
-      synthesizedContext: context,
-      synthesizedPolicyKind: .scroll,
-      synthesizedProfile: scrollDragProfile(releaseBehavior: releaseBehavior)
-    )
-#else
-    return executeDragGesture(
-      activeApp: activeApp,
-      x: x,
-      y: y,
-      x2: x2,
-      y2: y2,
-      durationMs: durationMs,
-      synthesized: false,
-      message: message,
-      synthesizedPolicyKind: .scroll
-    )
-#endif
-  }
-  private func executeDragGesture(
-    activeApp: XCUIApplication,
-    x: Double,
-    y: Double,
-    x2: Double,
-    y2: Double,
-    durationMs: Double?,
-    synthesized: Bool,
-    message: String,
-    synthesizedContext: SynthesizedCoordinateContext? = nil,
-    synthesizedPolicyKind: SynthesizedGesturePolicyKind,
-    synthesizedProfile: SynthesizedDragProfile = .continuous
-  ) -> Response {
-    let durationMs = durationMs ?? runnerDefaultDragDurationMs
-    let commandName = dragCommandName(message: message)
-    guard x.isFinite, y.isFinite, x2.isFinite, y2.isFinite else {
-      return Response(
-        ok: false,
-        error: ErrorPayload(code: "INVALID_ARGS", message: "\(commandName) requires finite coordinates")
-      )
-    }
-    if synthesized, let synthesizedResponse = executeSynthesizedDragGesture(
-      activeApp: activeApp,
-      x: x,
-      y: y,
-      x2: x2,
-      y2: y2,
-      durationMs: durationMs,
-      message: message,
-      context: synthesizedContext,
-      policyKind: synthesizedPolicyKind,
-      profile: synthesizedProfile
-    ) {
-      return synthesizedResponse
-    }
-    let dragPoints = keyboardAvoidingDragPoints(app: activeApp, x: x, y: y, x2: x2, y2: y2)
-    let dragFrame = resolvedDragVisualizationFrame(
-      app: activeApp,
-      x: dragPoints.x,
-      y: dragPoints.y,
-      x2: dragPoints.x2,
-      y2: dragPoints.y2
-    )
-    var fallback: GestureFallback?
-    if synthesized {
-      let durationMs = min(max(durationMs, 16), 10000)
-      let context = synthesizedCoordinateContext(
-        app: activeApp,
-        policy: synthesizedGesturePolicy(synthesizedPolicyKind)
-      )
-      let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
-        synthesizedDragAt(
-          app: activeApp,
-          x: dragPoints.x,
-          y: dragPoints.y,
-          x2: dragPoints.x2,
-          y2: dragPoints.y2,
-          durationMs: durationMs,
-          profile: synthesizedProfile,
-          context: context
-        )
-      }
-      if case .performed = outcome {
-        return gestureResponse(message: message, timing: timing, frame: .drag(dragFrame))
-      }
-      fallback = gestureFallback(strategy: "xctest-coordinate-drag", from: outcome)
-    }
-    let holdDuration = synthesized
-      ? synthesizedSwipeFallbackHoldDuration(durationMs: durationMs)
-      : coordinateDragHoldDuration()
-    let (timing, outcome) = performGesture(activeApp) {
-      dragAt(
-        app: activeApp,
-        x: dragPoints.x,
-        y: dragPoints.y,
-        x2: dragPoints.x2,
-        y2: dragPoints.y2,
-        holdDuration: holdDuration
-      )
-    }
-    if let response = unsupportedResponse(for: outcome) {
-      return response
-    }
-    return gestureResponse(
-      message: message,
-      timing: timing,
-      frame: .drag(dragFrame),
-      fallback: fallback
-    )
-  }
-  private func executeSynthesizedDragGesture(
-    activeApp: XCUIApplication,
-    x: Double,
-    y: Double,
-    x2: Double,
-    y2: Double,
-    durationMs: Double,
-    message: String,
-    context: SynthesizedCoordinateContext?,
-    policyKind: SynthesizedGesturePolicyKind,
-    profile: SynthesizedDragProfile
-  ) -> Response? {
-#if os(iOS)
-    let policy = synthesizedGesturePolicy(policyKind)
-    let context = context ?? synthesizedCoordinateContext(app: activeApp, policy: policy)
-    guard let plan = axFreeSynthesizedDragPlan(
-      app: activeApp,
-      x: x,
-      y: y,
-      x2: x2,
-      y2: y2,
-      context: context
-    )
-    else {
-      if context?.allowsXCTestCoordinateFallback == true {
-        logSynthesizedGesturePolicyDecision(kind: policyKind, context: context, fallbackAttempted: true)
-        return executeCoordinateDragFallback(
-          activeApp: activeApp,
-          x: x,
-          y: y,
-          x2: x2,
-          y2: y2,
-          durationMs: durationMs,
-          message: message,
-          fallback: nil
-        )
-      }
-      logSynthesizedGesturePolicyDecision(kind: policyKind, context: context, fallbackAttempted: false)
-      return Response(
-        ok: false,
-        error: ErrorPayload(
-          code: "INVALID_ARGS",
-          message: "\(dragCommandName(message: message)) could not resolve a finite synthesized coordinate frame"
-        )
-      )
-    }
-    let durationMs = min(max(durationMs, 16), 10000)
-    let dragFrame = axFreeDragVisualizationFrame(
-      x: plan.points.x,
-      y: plan.points.y,
-      x2: plan.points.x2,
-      y2: plan.points.y2,
-      referenceFrame: plan.referenceFrame
-    )
-    let (timing, outcome) = performGesture(activeApp, idleTimeout: false) {
-      synthesizedDragAt(
-        app: activeApp,
-        x: plan.points.x,
-        y: plan.points.y,
-        x2: plan.points.x2,
-        y2: plan.points.y2,
-        durationMs: durationMs,
-        profile: profile,
-        context: plan.context
-      )
-    }
-    if case .performed = outcome {
-      logSynthesizedGesturePolicyDecision(kind: policyKind, context: plan.context, fallbackAttempted: false)
-      return gestureResponse(message: message, timing: timing, frame: .drag(dragFrame))
-    }
-    if plan.context.allowsXCTestCoordinateFallback {
-      logSynthesizedGesturePolicyDecision(kind: policyKind, context: plan.context, fallbackAttempted: true)
-      return executeCoordinateDragFallback(
-        activeApp: activeApp,
-        x: plan.points.x,
-        y: plan.points.y,
-        x2: plan.points.x2,
-        y2: plan.points.y2,
-        durationMs: durationMs,
-        message: message,
-        fallback: gestureFallback(strategy: "xctest-coordinate-drag", from: outcome)
-      )
-    }
-    logSynthesizedGesturePolicyDecision(kind: policyKind, context: plan.context, fallbackAttempted: false)
-    return unsupportedResponse(for: outcome)
-#else
-    return nil
-#endif
-  }
-  private func executeCoordinateDragFallback(
-    activeApp: XCUIApplication,
-    x: Double,
-    y: Double,
-    x2: Double,
-    y2: Double,
-    durationMs: Double,
-    message: String,
-    fallback: GestureFallback?
-  ) -> Response {
-    let dragPoints = keyboardAvoidingDragPoints(app: activeApp, x: x, y: y, x2: x2, y2: y2)
-    let dragFrame = resolvedDragVisualizationFrame(
-      app: activeApp,
-      x: dragPoints.x,
-      y: dragPoints.y,
-      x2: dragPoints.x2,
-      y2: dragPoints.y2
-    )
-    let holdDuration = synthesizedSwipeFallbackHoldDuration(durationMs: durationMs)
-    let (timing, outcome) = performGesture(activeApp) {
-      dragAt(
-        app: activeApp,
-        x: dragPoints.x,
-        y: dragPoints.y,
-        x2: dragPoints.x2,
-        y2: dragPoints.y2,
-        holdDuration: holdDuration
-      )
-    }
-    if let response = unsupportedResponse(for: outcome) {
-      return response
-    }
-    return gestureResponse(
-      message: message,
-      timing: timing,
-      frame: .drag(dragFrame),
-      fallback: fallback
-    )
-  }
-  private func scrollKeyboardOccludedResponse(
-    direction: String,
-    keyboardMinY: Double,
-    visibleHeight: Double
-  ) -> Response {
-    return Response(
-      ok: false,
-      error: ErrorPayload(
-        code: ScrollViewportPolicy.occlusionRunnerCode,
-        message: String(
-          format:
-            "scroll %@ refused: the keyboard leaves %.0fpt of visible surface above it, too little to swipe",
-          direction,
-          visibleHeight
-        )
-      )
-    )
-  }
-  private func dragCommandName(message: String) -> String {
-    return message == "scrolled" ? "scroll" : "drag"
-  }
-  func currentXCTestFailureCount() -> Int {
-    return testRun?.failureCount ?? 0
-  }
-  func didRecordXCTestFailure(since failureCountBefore: Int) -> Bool {
-    return currentXCTestFailureCount() > failureCountBefore
-  }
-  private func xctestRecordedFailureResponse(command: Command, response: Response) -> Response? {
-    guard response.ok else { return nil }
-    if response.data?.runnerFatal == true {
-      return nil
-    }
-    guard !isReadOnlyCommand(command), !isRunnerLifecycleCommand(command.command) else {
-      return nil
-    }
-    return Response(
-      ok: false,
-      error: ErrorPayload(
-        code: "XCTEST_RECORDED_FAILURE",
-        message: "XCTest recorded a failure while executing \(command.command.rawValue); the action may not have been performed.",
-        hint: "The iOS runner session was invalidated. Re-observe with a fresh snapshot before retrying; if the accessibility tree is unavailable, use screenshot plus coordinate commands instead of retrying the tap blindly."
-      )
-    )
-  }
-  private func shouldSkipAppActivationPreflight(_ command: Command) -> Bool {
-#if os(iOS)
-    if command.command == .alert {
-      return true
-    }
-    if command.command == .actionButton {
-      return true
-    }
-    guard command.text == nil, command.selectorKey == nil else { return false }
-    guard hasCachedTargetForActivationSkip(command: command) else { return false }
-    return isCoordinateOnlyTap(command)
-#else
-    return false
-#endif
-  }
-  private func shouldRouteToSpringboardBlockingSystemModal(
-    _ command: Command
-  ) -> Bool {
-#if os(iOS)
-    guard isCoordinateOnlyTap(command) else {
-      return false
-    }
-    let probeDeadline = Date().addingTimeInterval(systemModalProbeBudget)
-    if Thread.isMainThread {
-      return firstBlockingSystemModal(
-        in: springboard,
-        deadline: probeDeadline
-      ) != nil
-    }
-    return boundedBlockingSystemAlertSnapshot(
-      deadline: probeDeadline
-    ) != nil
-#else
-    return false
-#endif
-  }
-  private func isCoordinateOnlyTap(_ command: Command) -> Bool {
-    return command.command == .tap
-      && command.text == nil
-      && command.selectorKey == nil
-      && command.x != nil
-      && command.y != nil
-  }
-  private func hasCachedTargetForActivationSkip(command: Command) -> Bool {
-    guard let currentApp, currentApp.state == .runningForeground else { return false }
-    guard let bundleId = command.appBundleId?.trimmingCharacters(in: .whitespacesAndNewlines),
-      !bundleId.isEmpty
-    else {
-      return true
-    }
-    return currentBundleId == bundleId
-  }
-  private func resolveAppWithoutActivation(command: Command) -> XCUIApplication {
-    guard let bundleId = command.appBundleId?
-      .trimmingCharacters(in: .whitespacesAndNewlines),
-      !bundleId.isEmpty
-    else {
-      return currentApp ?? app
-    }
-    if currentBundleId == bundleId, let currentApp {
-      return currentApp
-    }
-    return XCUIApplication(bundleIdentifier: bundleId)
-  }
-  func executeTypeCommand(activeApp: XCUIApplication, command: Command) -> Response {
-    guard let text = command.text else {
-      return Response(ok: false, error: ErrorPayload(message: "type requires text"))
-    }
-    let delaySeconds = Double(max(command.delayMs ?? 0, 0)) / 1000.0
-    let textEntryMode = resolveTextEntryMode(command)
-    let target: TextEntryTarget
-    var resolvedCoordinateContext: SynthesizedCoordinateContext?
-    var maestroNonHittableCoordinateFallbackUsed: Bool?
-    if command.allowNonHittableCoordinateFallback == true,
-      command.x != nil,
-      command.y != nil
-    {
-      maestroNonHittableCoordinateFallbackUsed = true
-    }
-    let focusStartedAt = Date()
-#if os(iOS)
-    let xCTestChannelPenalized = isSnapshotXCTestChannelPenalized(bundleId: currentBundleId)
-    var resolvedCoordinateTarget: TextEntryTarget?
-    if Self.shouldUseResolvedCoordinateTextEntryRoute(
-      repairMode: textEntryMode,
-      hasX: command.x != nil,
-      hasY: command.y != nil,
-      xCTestChannelPenalized: xCTestChannelPenalized
-    ), let x = command.x, let y = command.y {
-      let policyKind = SynthesizedGesturePolicyKind.coordinateTap
-      let context = synthesizedCoordinateContext(
-        app: activeApp,
-        policy: synthesizedGesturePolicy(policyKind)
-      )
-      let (_, outcome) = performGesture(activeApp, idleTimeout: false) {
-        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
-        )
-        resolvedCoordinateContext = context
-        resolvedCoordinateTarget = TextEntryTarget(
-          element: nil,
-          refreshPoint: CGPoint(x: x, y: y),
-          prefersFocusedElement: false
-        )
-      }
-    }
-#else
-    let xCTestChannelPenalized = false
-    let resolvedCoordinateTarget: TextEntryTarget? = nil
-#endif
-    if let resolvedCoordinateTarget {
-      target = resolvedCoordinateTarget
-    } else if let selectorKey = command.selectorKey, let selectorValue = command.selectorValue {
-      let match = findElement(
-        app: activeApp,
-        selectorKey: selectorKey,
-        selectorValue: selectorValue,
-        allowNonHittableFallback: command.allowNonHittableCoordinateFallback == true
-      )
-      if match.isAmbiguous {
-        return Response(ok: false, error: ErrorPayload(code: "AMBIGUOUS_MATCH", message: "selector matched multiple elements"))
-      }
-      guard let element = match.element else {
-        return Response(ok: false, error: ErrorPayload(code: "NO_MATCH", message: "selector did not match an element"))
-      }
-      guard isTextEntryElement(element) else {
-        return Response(ok: false, error: ErrorPayload(code: "INVALID_TARGET", message: "selector did not match a text input"))
-      }
-      if command.allowNonHittableCoordinateFallback == true {
-        maestroNonHittableCoordinateFallbackUsed = match.usedNonHittableFallback
-      }
-      target = focusTextInputForTextEntry(app: activeApp, element: element)
-    } else {
-      target = focusTextInputForTextEntry(app: activeApp, x: command.x, y: command.y)
-    }
-    NSLog(
-      "AGENT_DEVICE_RUNNER_TEXT_ENTRY_PHASE commandId=%@ phase=focus durationMs=%.1f chars=%d mode=%@",
-      command.commandId ?? "",
-      Date().timeIntervalSince(focusStartedAt) * 1000.0,
-      text.count,
-      textEntryModeName(textEntryMode)
-    )
-    if textEntryMode == .replacement {
-#if os(iOS)
-      let canReplaceResolvedFirstResponder = Self.shouldUseSynthesizedFirstResponderReplacement(
-        hasResolvedElement: target.element != nil,
-        hasRefreshPoint: target.refreshPoint != nil,
-        xCTestChannelPenalized: xCTestChannelPenalized
-      )
-#else
-      let canReplaceResolvedFirstResponder = false
-#endif
-      guard target.element != nil || canReplaceResolvedFirstResponder else {
-        let message =
-          (command.x != nil && command.y != nil)
-          ? "no text input found at the provided coordinates to clear"
-          : "no focused text input to clear"
-        return Response(ok: false, error: ErrorPayload(message: message))
-      }
-    }
-    let textResult = typeTextReliably(
-      app: activeApp,
-      target: target,
-      text: text,
-      delaySeconds: delaySeconds,
-      repairMode: textEntryMode,
-      xCTestChannelPenalized: xCTestChannelPenalized,
-      synthesizer: PrivateXCTestTextEntrySynthesizer(),
-      commandId: command.commandId
-    )
-    if let failure = textResult.failure {
-      return Response(
-        ok: false,
-        error: ErrorPayload(code: failure.rawValue, message: failure.message, hint: failure.hint)
-      )
-    }
-    if textResult.verified == false {
-      let expected = textResult.expectedText ?? ""
-      let observed = textResult.observedText ?? ""
-      return Response(
-        ok: false,
-        error: ErrorPayload(
-          code: "TEXT_ENTRY_MISMATCH",
-          message: "text entry verification failed: expected \"\(expected)\", observed \"\(observed)\""
-        )
-      )
-    }
-    let point = target.refreshPoint
-    let frame: CGRect
-    if let resolvedCoordinateContext {
-      frame = resolvedCoordinateContext.referenceFrame
-    } else if point != nil {
-      frame = activeApp.frame
-    } else {
-      frame = .zero
-    }
-    return Response(
-      ok: true,
-      data: DataPayload(
-        message: textResult.repaired ? "typed after repair" : "typed",
-        x: point.map { Double($0.x) },
-        y: point.map { Double($0.y) },
-        referenceWidth: frame.isEmpty ? nil : Double(frame.width),
-        referenceHeight: frame.isEmpty ? nil : Double(frame.height),
-        maestroNonHittableCoordinateFallbackUsed: maestroNonHittableCoordinateFallbackUsed,
-        textEntryRoute: textResult.textEntryRoute
-      )
-    )
-  }
 }