agent-device 0.19.2 → 0.20.0

package/dist/{apple-runner → apple/runner}/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.m

@@ -1,7 +1,6 @@
 #import "RunnerSynthesizedGesture.h"
 
 #import <CoreGraphics/CoreGraphics.h>
-#import <math.h>
 #import <objc/message.h>
 
 typedef NSInteger (*RunnerMsgSendInteger)(id, SEL);
@@ -27,6 +26,13 @@ typedef struct {
   SEL liftSelector;
 } RunnerXCTestEventBridge;
 
+typedef id (*RunnerDragPointerPathFactory)(
+  const RunnerXCTestEventBridge *,
+  CGPoint,
+  CGPoint,
+  double
+);
+
 static NSString * _Nullable RunnerResolveXCTestEventBridge(
   id application,
   RunnerXCTestEventBridge *bridge
@@ -34,64 +40,51 @@ static NSString * _Nullable RunnerResolveXCTestEventBridge(
 static NSString * _Nullable RunnerRequireClass(Class cls, NSString *className);
 static NSString * _Nullable RunnerRequireSelector(Class cls, SEL selector, NSString *selectorName);
 static NSString * _Nullable RunnerRequireApplicationSelector(id application, SEL selector, NSString *selectorName);
-static id RunnerPointerPath(
+static id RunnerSwipePointerPath(
   const RunnerXCTestEventBridge *bridge,
   CGPoint start,
-  double x,
-  double y,
-  double dx,
-  double dy,
-  double scale,
-  double degrees,
-  double radius,
-  double durationMs,
-  double side
+  CGPoint end,
+  double durationMs
 );
-static id RunnerSwipePointerPath(
+static id RunnerContinuousDragPointerPath(
   const RunnerXCTestEventBridge *bridge,
   CGPoint start,
   CGPoint end,
   double durationMs
 );
+static NSString * _Nullable RunnerTrySynthesizeDrag(
+  id application,
+  CGPoint start,
+  CGPoint end,
+  double durationMs,
+  NSString *recordName,
+  RunnerDragPointerPathFactory pathFactory
+);
+// XCTest's proven swipe profile reaches the endpoint in 100 ms, then holds for the planned
+// fling duration. Fast movement is what lets UIKit distinguish a fling from a timed pan.
+static const NSTimeInterval RunnerSwipeMovementDurationSeconds = 0.1;
 static id RunnerTapPointerPath(
   const RunnerXCTestEventBridge *bridge,
   CGPoint point
 );
-static CGPoint RunnerPointerPointAt(
-  double x,
-  double y,
-  double dx,
-  double dy,
-  double scale,
-  double degrees,
-  double baseRadius,
-  double t,
-  double side
-);
-static CGPoint RunnerInterpolatedPoint(CGPoint start, CGPoint end, double t);
-static double RunnerSmoothStep(double t);
 
 @implementation RunnerSynthesizedGesture
 
-+ (NSString * _Nullable)synthesizeTransformWithApplication:(id)application
-                                                         x:(double)x
-                                                         y:(double)y
-                                                        dx:(double)dx
-                                                        dy:(double)dy
-                                                     scale:(double)scale
-                                                   degrees:(double)degrees
-                                                    radius:(double)radius
-                                                durationMs:(double)durationMs {
++ (NSString * _Nullable)synthesizeSwipeWithApplication:(id)application
+                                                    x:(double)x
+                                                    y:(double)y
+                                                   x2:(double)x2
+                                                   y2:(double)y2
+                                            durationMs:(double)durationMs {
   @try {
-    return [self trySynthesizeTransformWithApplication:application
-                                                     x:x
-                                                     y:y
-                                                    dx:dx
-                                                    dy:dy
-                                                 scale:scale
-                                               degrees:degrees
-                                                radius:radius
-                                            durationMs:durationMs];
+    return RunnerTrySynthesizeDrag(
+      application,
+      CGPointMake(x, y),
+      CGPointMake(x2, y2),
+      durationMs,
+      @"agent-device-swipe",
+      RunnerSwipePointerPath
+    );
   } @catch (NSException *exception) {
     NSString *name = exception.name ?: @"NSException";
     NSString *reason = exception.reason ?: @"private XCTest event synthesis failed";
@@ -99,19 +92,21 @@ static double RunnerSmoothStep(double t);
   }
 }
 
-+ (NSString * _Nullable)synthesizeSwipeWithApplication:(id)application
-                                                    x:(double)x
-                                                    y:(double)y
-                                                   x2:(double)x2
-                                                   y2:(double)y2
-                                            durationMs:(double)durationMs {
++ (NSString * _Nullable)synthesizeContinuousDragWithApplication:(id)application
+                                                             x:(double)x
+                                                             y:(double)y
+                                                            x2:(double)x2
+                                                            y2:(double)y2
+                                                     durationMs:(double)durationMs {
   @try {
-    return [self trySynthesizeSwipeWithApplication:application
-                                                x:x
-                                                y:y
-                                               x2:x2
-                                               y2:y2
-                                        durationMs:durationMs];
+    return RunnerTrySynthesizeDrag(
+      application,
+      CGPointMake(x, y),
+      CGPointMake(x2, y2),
+      durationMs,
+      @"agent-device-continuous-drag",
+      RunnerContinuousDragPointerPath
+    );
   } @catch (NSException *exception) {
     NSString *name = exception.name ?: @"NSException";
     NSString *reason = exception.reason ?: @"private XCTest event synthesis failed";
@@ -131,84 +126,94 @@ static double RunnerSmoothStep(double t);
   }
 }
 
-+ (NSInteger)interfaceOrientationForApplication:(id)application {
-  SEL selector = NSSelectorFromString(@"interfaceOrientation");
-  if (![application respondsToSelector:selector]) {
-    return 0;  // UIInterfaceOrientationUnknown
-  }
-  return ((RunnerMsgSendInteger)objc_msgSend)(application, selector);
-}
-
-+ (NSString * _Nullable)trySynthesizeTransformWithApplication:(id)application
-                                                            x:(double)x
-                                                            y:(double)y
-                                                           dx:(double)dx
-                                                           dy:(double)dy
-                                                        scale:(double)scale
-                                                      degrees:(double)degrees
-                                                       radius:(double)radius
-                                                   durationMs:(double)durationMs {
-  RunnerXCTestEventBridge bridge;
-  NSString *missing = RunnerResolveXCTestEventBridge(application, &bridge);
-  if (missing != nil) {
-    return missing;
-  }
-
-  NSInteger interfaceOrientation =
-    ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.interfaceOrientationSelector);
-  NSInteger targetProcessID = ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.processIDSelector);
-  if (targetProcessID <= 0) {
-    return @"private XCTest event synthesis unavailable: could not resolve target process ID";
-  }
-
-  id record = ((RunnerMsgSendInitRecord)objc_msgSend)(
-    [bridge.recordClass alloc],
-    bridge.initRecordSelector,
-    @"agent-device-transform",
-    interfaceOrientation
-  );
-  if (record == nil) {
-    return @"private XCTest event synthesis failed: could not create event record";
-  }
-  ((RunnerMsgSendSetInteger)objc_msgSend)(record, bridge.setTargetProcessIDSelector, targetProcessID);
++ (NSString * _Nullable)synthesizeGestureWithApplication:(id)application
+                                          pointerSamples:(NSArray<NSArray<NSDictionary<NSString *, NSNumber *> *> *> *)pointerSamples {
+  @try {
+    RunnerXCTestEventBridge bridge;
+    NSString *missing = RunnerResolveXCTestEventBridge(application, &bridge);
+    if (missing != nil) return missing;
+
+    NSInteger interfaceOrientation =
+      ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.interfaceOrientationSelector);
+    NSInteger targetProcessID =
+      ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.processIDSelector);
+    if (targetProcessID <= 0) {
+      return @"private XCTest event synthesis unavailable: could not resolve target process ID";
+    }
 
-  double sides[] = {1.0, -1.0};
-  for (int index = 0; index < 2; index += 1) {
-    double side = sides[index];
-    id path = RunnerPointerPath(
-      &bridge,
-      RunnerPointerPointAt(x, y, dx, dy, scale, degrees, radius, 0.0, side),
-      x,
-      y,
-      dx,
-      dy,
-      scale,
-      degrees,
-      radius,
-      durationMs,
-      side
+    id record = ((RunnerMsgSendInitRecord)objc_msgSend)(
+      [bridge.recordClass alloc],
+      bridge.initRecordSelector,
+      @"agent-device-gesture-plan",
+      interfaceOrientation
     );
-    if (path == nil) {
-      return @"private XCTest event synthesis failed: could not create pointer path";
+    if (record == nil) {
+      return @"private XCTest event synthesis failed: could not create event record";
+    }
+    ((RunnerMsgSendSetInteger)objc_msgSend)(record, bridge.setTargetProcessIDSelector, targetProcessID);
+
+    for (NSArray<NSDictionary<NSString *, NSNumber *> *> *samples in pointerSamples) {
+      NSDictionary<NSString *, NSNumber *> *first = samples.firstObject;
+      if (first == nil) return @"private XCTest event synthesis failed: empty pointer path";
+      CGPoint start = CGPointMake(first[@"x"].doubleValue, first[@"y"].doubleValue);
+      id path = ((RunnerMsgSendInitPath)objc_msgSend)(
+        [bridge.pathClass alloc],
+        bridge.initPathSelector,
+        start,
+        first[@"offsetMs"].doubleValue / 1000.0
+      );
+      if (path == nil) {
+        return @"private XCTest event synthesis failed: could not create pointer path";
+      }
+      for (NSUInteger index = 1; index < samples.count; index += 1) {
+        NSDictionary<NSString *, NSNumber *> *sample = samples[index];
+        CGPoint point = CGPointMake(sample[@"x"].doubleValue, sample[@"y"].doubleValue);
+        ((RunnerMsgSendPathMove)objc_msgSend)(
+          path,
+          bridge.moveSelector,
+          point,
+          sample[@"offsetMs"].doubleValue / 1000.0
+        );
+      }
+      NSDictionary<NSString *, NSNumber *> *last = samples.lastObject;
+      ((RunnerMsgSendPathOffset)objc_msgSend)(
+        path,
+        bridge.liftSelector,
+        last[@"offsetMs"].doubleValue / 1000.0
+      );
+      ((RunnerMsgSendAddPath)objc_msgSend)(record, bridge.addPathSelector, path);
     }
-    ((RunnerMsgSendAddPath)objc_msgSend)(record, bridge.addPathSelector, path);
+
+    NSError *error = nil;
+    BOOL ok = ((RunnerMsgSendSynthesize)objc_msgSend)(record, bridge.synthesizeSelector, &error);
+    if (!ok) {
+      NSString *detail = error.localizedDescription ?: @"synthesizeWithError returned false";
+      return [NSString stringWithFormat:@"private XCTest event synthesis failed: %@", detail];
+    }
+    return nil;
+  } @catch (NSException *exception) {
+    NSString *name = exception.name ?: @"NSException";
+    NSString *reason = exception.reason ?: @"private XCTest event synthesis failed";
+    return [NSString stringWithFormat:@"%@: %@", name, reason];
   }
+}
 
-  NSError *error = nil;
-  BOOL ok = ((RunnerMsgSendSynthesize)objc_msgSend)(record, bridge.synthesizeSelector, &error);
-  if (!ok) {
-    NSString *detail = error.localizedDescription ?: @"synthesizeWithError returned false";
-    return [NSString stringWithFormat:@"private XCTest event synthesis failed: %@", detail];
++ (NSInteger)interfaceOrientationForApplication:(id)application {
+  SEL selector = NSSelectorFromString(@"interfaceOrientation");
+  if (![application respondsToSelector:selector]) {
+    return 0;  // UIInterfaceOrientationUnknown
   }
-  return nil;
+  return ((RunnerMsgSendInteger)objc_msgSend)(application, selector);
 }
 
-+ (NSString * _Nullable)trySynthesizeSwipeWithApplication:(id)application
-                                                       x:(double)x
-                                                       y:(double)y
-                                                      x2:(double)x2
-                                                      y2:(double)y2
-                                               durationMs:(double)durationMs {
+static NSString * _Nullable RunnerTrySynthesizeDrag(
+  id application,
+  CGPoint start,
+  CGPoint end,
+  double durationMs,
+  NSString *recordName,
+  RunnerDragPointerPathFactory pathFactory
+) {
   RunnerXCTestEventBridge bridge;
   NSString *missing = RunnerResolveXCTestEventBridge(application, &bridge);
   if (missing != nil) {
@@ -225,7 +230,7 @@ static double RunnerSmoothStep(double t);
   id record = ((RunnerMsgSendInitRecord)objc_msgSend)(
     [bridge.recordClass alloc],
     bridge.initRecordSelector,
-    @"agent-device-swipe",
+    recordName,
     interfaceOrientation
   );
   if (record == nil) {
@@ -233,7 +238,7 @@ static double RunnerSmoothStep(double t);
   }
   ((RunnerMsgSendSetInteger)objc_msgSend)(record, bridge.setTargetProcessIDSelector, targetProcessID);
 
-  id path = RunnerSwipePointerPath(&bridge, CGPointMake(x, y), CGPointMake(x2, y2), durationMs);
+  id path = pathFactory(&bridge, start, end, durationMs);
   if (path == nil) {
     return @"private XCTest event synthesis failed: could not create pointer path";
   }
@@ -377,18 +382,12 @@ static NSString * _Nullable RunnerRequireApplicationSelector(
   return nil;
 }
 
-static id RunnerPointerPath(
+
+static id RunnerSwipePointerPath(
   const RunnerXCTestEventBridge *bridge,
   CGPoint start,
-  double x,
-  double y,
-  double dx,
-  double dy,
-  double scale,
-  double degrees,
-  double radius,
-  double durationMs,
-  double side
+  CGPoint end,
+  double durationMs
 ) {
   id path =
     ((RunnerMsgSendInitPath)objc_msgSend)([bridge->pathClass alloc], bridge->initPathSelector, start, 0.0);
@@ -396,20 +395,22 @@ static id RunnerPointerPath(
     return nil;
   }
 
-  int frameCount = MAX(3, (int)(durationMs / 16.0));
   NSTimeInterval durationSeconds = durationMs / 1000.0;
-  for (int index = 1; index <= frameCount; index += 1) {
-    double t = (double)index / (double)frameCount;
-    CGPoint point = RunnerPointerPointAt(x, y, dx, dy, scale, degrees, radius, t, side);
-    NSTimeInterval offset = durationSeconds * t;
-    ((RunnerMsgSendPathMove)objc_msgSend)(path, bridge->moveSelector, point, offset);
-  }
-
-  ((RunnerMsgSendPathOffset)objc_msgSend)(path, bridge->liftSelector, durationSeconds);
+  ((RunnerMsgSendPathMove)objc_msgSend)(
+    path,
+    bridge->moveSelector,
+    end,
+    RunnerSwipeMovementDurationSeconds
+  );
+  ((RunnerMsgSendPathOffset)objc_msgSend)(
+    path,
+    bridge->liftSelector,
+    RunnerSwipeMovementDurationSeconds + durationSeconds
+  );
   return path;
 }
 
-static id RunnerSwipePointerPath(
+static id RunnerContinuousDragPointerPath(
   const RunnerXCTestEventBridge *bridge,
   CGPoint start,
   CGPoint end,
@@ -425,9 +426,12 @@ static id RunnerSwipePointerPath(
   NSTimeInterval durationSeconds = durationMs / 1000.0;
   for (int index = 1; index <= frameCount; index += 1) {
     double t = (double)index / (double)frameCount;
-    CGPoint point = RunnerInterpolatedPoint(start, end, RunnerSmoothStep(t));
-    NSTimeInterval offset = durationSeconds * t;
-    ((RunnerMsgSendPathMove)objc_msgSend)(path, bridge->moveSelector, point, offset);
+    double easedT = t * t * (3.0 - 2.0 * t);
+    CGPoint point = CGPointMake(
+      start.x + (end.x - start.x) * easedT,
+      start.y + (end.y - start.y) * easedT
+    );
+    ((RunnerMsgSendPathMove)objc_msgSend)(path, bridge->moveSelector, point, durationSeconds * t);
   }
 
   ((RunnerMsgSendPathOffset)objc_msgSend)(path, bridge->liftSelector, durationSeconds);
@@ -447,39 +451,4 @@ static id RunnerTapPointerPath(
   return path;
 }
 
-static CGPoint RunnerPointerPointAt(
-  double x,
-  double y,
-  double dx,
-  double dy,
-  double scale,
-  double degrees,
-  double baseRadius,
-  double t,
-  double side
-) {
-  double centerX = x + dx * t;
-  double centerY = y + dy * t;
-  double startRadius = baseRadius / MAX(scale, 1.0);
-  double endRadius = baseRadius;
-  if (scale < 1.0) {
-    startRadius = baseRadius;
-    endRadius = baseRadius * scale;
-  }
-  double radius = startRadius + (endRadius - startRadius) * t;
-  double angle = (-M_PI_2) + (degrees * M_PI / 180.0) * t;
-  return CGPointMake(centerX + cos(angle) * radius * side, centerY + sin(angle) * radius * side);
-}
-
-static CGPoint RunnerInterpolatedPoint(CGPoint start, CGPoint end, double t) {
-  return CGPointMake(
-    start.x + (end.x - start.x) * t,
-    start.y + (end.y - start.y) * t
-  );
-}
-
-static double RunnerSmoothStep(double t) {
-  return t * t * (3.0 - 2.0 * t);
-}
-
 @end

package/dist/{apple-runner → apple/runner}/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Alert.swift

@@ -1,48 +1,89 @@
 import XCTest
 
 extension RunnerTests {
+  enum RunnerAlertSource {
+    case blockingSystemModal
+    case appAlert
+    case dismissPopup
+  }
+
   struct RunnerAlert {
     let root: XCUIElement
     let ownerApp: XCUIApplication
     let buttons: [XCUIElement]
+    let source: RunnerAlertSource
+  }
+
+  static let defaultAlertCommandTimeout: TimeInterval = 10
+
+  static func alertCommandTimeout(timeoutMs: Double?) -> TimeInterval {
+    guard let timeoutMs, timeoutMs.isFinite else { return defaultAlertCommandTimeout }
+    return max(0.001, timeoutMs / 1000)
   }
 
-  func resolveAlert(app activeApp: XCUIApplication) -> RunnerAlert? {
+  func resolveAlert(app activeApp: XCUIApplication, deadline: Date) -> RunnerAlert? {
 #if !os(macOS)
-    if let systemModal = firstBlockingSystemModal(in: springboard) {
-      return runnerAlert(root: systemModal, ownerApp: springboard)
+    switch resolveBlockingSystemModal(deadline: deadline) {
+    case .resolved(let modal):
+      return runnerAlert(modal)
+    case .unresolved:
+      return nil
+    case .absent:
+      break
     }
 #endif
-    if let alert = firstExistingElement(in: activeApp.alerts.allElementsBoundByIndex) {
-      return runnerAlert(root: alert, ownerApp: activeApp)
+    // Guard the query: when a remote-hosted modal (e.g. the AccessorySetupKit
+    // picker) was just dismissed, the dismissal re-check re-enters here with the
+    // now-gone host as `activeApp`, and its `alerts` query raises
+    // kAXErrorServerNotFound. safeElementsQuery absorbs it and reports no alert.
+    if let alert = firstExistingElement(in: safeElementsQuery { activeApp.alerts.allElementsBoundByIndex }) {
+      return runnerAlert(root: alert, ownerApp: activeApp, source: .appAlert)
     }
     if let popup = firstDismissPopupWindow(in: activeApp) {
-      return runnerAlert(root: popup, ownerApp: activeApp)
+      return runnerAlert(root: popup, ownerApp: activeApp, source: .dismissPopup)
     }
     return nil
   }
 
-  func handleAlert(_ alert: RunnerAlert, action: String) -> Response {
+  func handleAlert(_ alert: RunnerAlert, action: String, deadline: Date) -> Response {
     if action == "accept" || action == "dismiss" {
       guard let button = chooseAlertButton(alert.buttons, action: action) else {
         return Response(ok: false, error: ErrorPayload(message: "alert \(action) button not found"))
       }
+      let previousTitle = preferredAlertTitle(alert.root, buttons: alert.buttons)
+      let actionButtonLabel = button.label.trimmingCharacters(in: .whitespacesAndNewlines)
+      let actionButtonFrame = button.frame
       let outcome = activateElement(app: alert.ownerApp, element: button, action: "alert \(action)")
       if let response = unsupportedResponse(for: outcome) {
         return response
       }
       sleepFor(0.2)
-      if alertStillVisible(alert, actionButtonLabel: button.label) {
-        let frame = button.frame
-        if !frame.isNull && !frame.isEmpty {
-          let coordinateOutcome = tapAt(app: alert.ownerApp, x: frame.midX, y: frame.midY)
+      if alertStillVisible(
+        in: alert.ownerApp,
+        source: alert.source,
+        previousTitle: previousTitle,
+        actionButtonLabel: actionButtonLabel,
+        deadline: deadline
+      ) {
+        if !actionButtonFrame.isNull && !actionButtonFrame.isEmpty {
+          let coordinateOutcome = tapAt(
+            app: alert.ownerApp,
+            x: actionButtonFrame.midX,
+            y: actionButtonFrame.midY
+          )
           if let response = unsupportedResponse(for: coordinateOutcome) {
             return response
           }
           sleepFor(0.2)
         }
       }
-      if alertStillVisible(alert, actionButtonLabel: button.label) {
+      if alertStillVisible(
+        in: alert.ownerApp,
+        source: alert.source,
+        previousTitle: previousTitle,
+        actionButtonLabel: actionButtonLabel,
+        deadline: deadline
+      ) {
         return Response(
           ok: false,
           error: ErrorPayload(
@@ -64,26 +105,79 @@ extension RunnerTests {
     )
   }
 
-  private func runnerAlert(root: XCUIElement, ownerApp: XCUIApplication) -> RunnerAlert? {
+  private func runnerAlert(_ modal: ResolvedBlockingSystemModal) -> RunnerAlert? {
+    let buttons = modal.actions.filter { isEnabledElement($0) }
+    guard !buttons.isEmpty else {
+      return nil
+    }
+    return RunnerAlert(
+      root: modal.root,
+      ownerApp: modal.ownerApp,
+      buttons: buttons,
+      source: .blockingSystemModal
+    )
+  }
+
+  private func runnerAlert(
+    root: XCUIElement,
+    ownerApp: XCUIApplication,
+    source: RunnerAlertSource
+  ) -> RunnerAlert? {
     let buttons = actionableElements(in: root).filter { isEnabledElement($0) }
     guard !buttons.isEmpty else {
       return nil
     }
-    return RunnerAlert(root: root, ownerApp: ownerApp, buttons: buttons)
+    return RunnerAlert(root: root, ownerApp: ownerApp, buttons: buttons, source: source)
   }
 
-  private func alertStillVisible(_ alert: RunnerAlert, actionButtonLabel: String) -> Bool {
-    guard let current = resolveAlert(app: alert.ownerApp) else {
+  private func alertStillVisible(
+    in ownerApp: XCUIApplication,
+    source: RunnerAlertSource,
+    previousTitle: String,
+    actionButtonLabel: String,
+    deadline: Date
+  ) -> Bool {
+    guard Date() < deadline,
+          let current = resolveAlert(source: source, app: ownerApp, deadline: deadline)
+    else {
       return false
     }
-    let previousTitle = preferredAlertTitle(alert.root, buttons: alert.buttons)
     let currentTitle = preferredAlertTitle(current.root, buttons: current.buttons)
     if previousTitle == currentTitle {
       return true
     }
-    let normalizedActionLabel = actionButtonLabel.trimmingCharacters(in: .whitespacesAndNewlines)
     return current.buttons.contains { button in
-      button.label.trimmingCharacters(in: .whitespacesAndNewlines) == normalizedActionLabel
+      button.label.trimmingCharacters(in: .whitespacesAndNewlines) == actionButtonLabel
+    }
+  }
+
+  private func resolveAlert(
+    source: RunnerAlertSource,
+    app: XCUIApplication,
+    deadline: Date
+  ) -> RunnerAlert? {
+    switch source {
+    case .blockingSystemModal:
+#if os(macOS)
+      return nil
+#else
+      guard case .resolved(let modal) = resolveBlockingSystemModal(deadline: deadline) else {
+        return nil
+      }
+      return runnerAlert(modal)
+#endif
+    case .appAlert:
+      guard let alert = firstExistingElement(
+        in: safeElementsQuery { app.alerts.allElementsBoundByIndex }
+      ) else {
+        return nil
+      }
+      return runnerAlert(root: alert, ownerApp: app, source: .appAlert)
+    case .dismissPopup:
+      guard let popup = firstDismissPopupWindow(in: app) else {
+        return nil
+      }
+      return runnerAlert(root: popup, ownerApp: app, source: .dismissPopup)
     }
   }