appium-webdriveragent 16.1.1 → 16.1.3

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [16.1.3](https://github.com/appium/WebDriverAgent/compare/v16.1.2...v16.1.3) (2026-08-03)
+
+### Bug Fixes
+
+* Optimize alert operations ([#1193](https://github.com/appium/WebDriverAgent/issues/1193)) ([2bc1c40](https://github.com/appium/WebDriverAgent/commit/2bc1c40d20883a9b924b8a177be4d43ffd497901))
+
+## [16.1.2](https://github.com/appium/WebDriverAgent/compare/v16.1.1...v16.1.2) (2026-08-03)
+
+### Bug Fixes
+
+* Optimize class chain lookup ([#1194](https://github.com/appium/WebDriverAgent/issues/1194)) ([47cbbb5](https://github.com/appium/WebDriverAgent/commit/47cbbb597495ac78c4290c27c2ef0ee349004406))
+
 ## [16.1.1](https://github.com/appium/WebDriverAgent/compare/v16.1.0...v16.1.1) (2026-08-01)
 
 ### Miscellaneous Chores

package/WebDriverAgentLib/Categories/XCUIApplication+FBAlert.h

@@ -8,6 +8,8 @@
 
 #import <XCTest/XCTest.h>
 
+#import "FBXCElementSnapshot.h"
+
 NS_ASSUME_NONNULL_BEGIN
 
 @interface XCUIApplication (FBAlert)
@@ -16,19 +18,29 @@ NS_ASSUME_NONNULL_BEGIN
 extern NSString *const FB_SAFARI_APP_NAME;
 
 /**
- Retrieve the current alert element
-
- @return Alert element instance
+ Retrieve the currently displayed alert element, if any, using a single
+ predicate-filtered query (Alert, Sheet, or ScrollView type) instead of
+ snapshotting and walking the whole application tree - the cost stays
+ proportional to the number of matching elements rather than the
+ size/depth of the whole app.
+
+ @param snapshotOut On return, set to the element's snapshot if resolving it
+ already required taking one as a side effect (the iPad sheet popover check,
+ or the Safari web-alert scan) - left untouched if no snapshot was taken, so
+ callers should seed it with nil beforehand. Pass NULL if not needed.
+ @return Alert element instance, or nil if no alert is present
  */
-- (nullable XCUIElement *)fb_alertElement;
+- (nullable XCUIElement *)fb_alertElementWithSnapshot:(id<FBXCElementSnapshot> _Nullable * _Nullable)snapshotOut;
 
 /**
- Retrieve an alert element hosted by the iOS 18+ limited access permission prompt
- process. See https://github.com/appium/appium/issues/20591
+ Retrieve the application hosting the iOS 18+ limited access permission prompt,
+ cheaply gated on its running state so callers can avoid resolving its alert
+ snapshot when the prompt process isn't in the foreground.
+ See https://github.com/appium/appium/issues/20591
 
- @return Alert element instance if the prompt is present, otherwise nil
+ @return The prompt application if it is running in the foreground, otherwise nil
  */
-+ (nullable XCUIElement *)fb_limitedAccessPromptAlertElement;
++ (nullable XCUIApplication *)fb_limitedAccessPromptApplication;
 
 @end
 

package/WebDriverAgentLib/Categories/XCUIApplication+FBAlert.m

@@ -8,7 +8,6 @@
 
 #import "XCUIApplication+FBAlert.h"
 
-#import "FBMacros.h"
 #import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIElement+FBUtilities.h"
@@ -24,95 +23,152 @@ static NSString *const FB_LIMITED_ACCESS_PROMPT_BUNDLE_ID = @"com.apple.Contacts
 
 @implementation XCUIApplication (FBAlert)
 
-+ (nullable XCUIElement *)fb_limitedAccessPromptAlertElement
++ (nullable XCUIApplication *)fb_limitedAccessPromptApplication
 {
   XCUIApplication *promptApp = [[XCUIApplication alloc] initWithBundleIdentifier:FB_LIMITED_ACCESS_PROMPT_BUNDLE_ID];
-  if (promptApp.state < XCUIApplicationStateRunningForeground) {
-    return nil;
-  }
-  return promptApp.fb_alertElement;
+  return promptApp.state < XCUIApplicationStateRunningForeground ? nil : promptApp;
 }
 
-- (nullable XCUIElement *)fb_alertElementFromSafariWithScrollView:(XCUIElement *)scrollView
-                                                     viewSnapshot:(id<FBXCElementSnapshot>)viewSnapshot
++ (nullable id<FBXCElementSnapshot>)fb_findSafariAlertSnapshotInScrollView:(id<FBXCElementSnapshot>)scrollViewSnapshot
 {
-  CGRect appFrame = viewSnapshot.frame;
-  NSPredicate *dstViewMatchPredicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot, NSDictionary *bindings) {
-    CGRect curFrame = snapshot.frame;
-    if (!CGRectEqualToRect(appFrame, curFrame)
-        && curFrame.origin.x > 0 && curFrame.size.width < appFrame.size.width) {
-      CGFloat possibleCenterX = (appFrame.size.width - curFrame.size.width) / 2;
-      return fabs(possibleCenterX - curFrame.origin.x) < MAX_CENTER_DELTA;
+  if (nil == scrollViewSnapshot) {
+    return nil;
+  }
+
+  CGRect appFrame = scrollViewSnapshot.frame;
+
+  __block id<FBXCElementSnapshot> webView = nil;
+  [scrollViewSnapshot enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
+    if (nil == webView && nil != descendant.identifier && [descendant.identifier isEqualToString:@"WebView"]) {
+      webView = descendant;
     }
-    return NO;
   }];
-  NSPredicate *dstViewContainPredicate1 = [NSPredicate predicateWithFormat:@"elementType == %lu", XCUIElementTypeTextView];
-  NSPredicate *dstViewContainPredicate2 = [NSPredicate predicateWithFormat:@"elementType == %lu", XCUIElementTypeButton];
-  // Find the first XCUIElementTypeOther which is the grandchild of the web view
-  // and is horizontally aligned to the center of the screen
-  XCUIElement *candidate = [[[[[[scrollView descendantsMatchingType:XCUIElementTypeAny]
-       matchingIdentifier:@"WebView"]
-      descendantsMatchingType:XCUIElementTypeOther]
-     matchingPredicate:dstViewMatchPredicate]
-    containingPredicate:dstViewContainPredicate1]
-   containingPredicate:dstViewContainPredicate2].allElementsBoundByIndex.firstObject;
-
-  if (nil == candidate) {
+  if (nil == webView) {
     return nil;
   }
-  // ...and contains one to two buttons
-  // and conatins at least one text view
-  __block NSUInteger buttonsCount = 0;
-  __block NSUInteger textViewsCount = 0;
-  id<FBXCElementSnapshot> snapshot = candidate.fb_cachedSnapshot ?: [candidate fb_customSnapshot];
-  [snapshot enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
-    XCUIElementType curType = descendant.elementType;
-    if (curType == XCUIElementTypeButton) {
-      buttonsCount++;
-    } else if (curType == XCUIElementTypeTextView) {
-      textViewsCount++;
+
+  // Find the first XCUIElementTypeOther which is the grandchild of the web view
+  // and is horizontally aligned to the center of the screen, and contains one
+  // to two buttons and at least one text view.
+  __block id<FBXCElementSnapshot> candidate = nil;
+  [webView enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
+    if (nil != candidate || descendant.elementType != XCUIElementTypeOther) {
+      return;
+    }
+    CGRect curFrame = descendant.frame;
+    if (CGRectEqualToRect(appFrame, curFrame)
+        || curFrame.origin.x <= 0
+        || curFrame.size.width >= appFrame.size.width) {
+      return;
+    }
+    CGFloat possibleCenterX = (appFrame.size.width - curFrame.size.width) / 2;
+    if (fabs(possibleCenterX - curFrame.origin.x) >= MAX_CENTER_DELTA) {
+      return;
+    }
+
+    __block NSUInteger buttonsCount = 0;
+    __block NSUInteger textViewsCount = 0;
+    [descendant enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> innerDescendant) {
+      XCUIElementType curType = innerDescendant.elementType;
+      if (curType == XCUIElementTypeButton) {
+        buttonsCount++;
+      } else if (curType == XCUIElementTypeTextView) {
+        textViewsCount++;
+      }
+    }];
+    if (buttonsCount >= 1 && buttonsCount <= 2 && textViewsCount > 0) {
+      candidate = descendant;
     }
   }];
-  return (buttonsCount >= 1 && buttonsCount <= 2 && textViewsCount > 0) ? candidate : nil;
+  return candidate;
 }
 
-- (XCUIElement *)fb_alertElement
+// Resolving a query (e.g. allElementsBoundByIndex) is itself
+// as expensive as taking a snapshot - it has to walk/resolve the matching
+// subtree either way. So this issues exactly ONE such query, matching all
+// three candidate types at once, instead of one query per type: querying
+// Alert, then Sheet, then ScrollView separately would pay that cost up to
+// three times over, which is worse than a single whole-app snapshot in the
+// common case where no alert is present at all (the query comes back
+// empty on the very first attempt). Priority is then resolved in memory
+// over the (typically 0-1 element) result: an Alert always wins outright,
+// a Sheet only loses to an Alert, and a ScrollView (the Safari web-alert
+// case) is the last resort. Per-candidate ancestor/subtree checks (the
+// iPad popover check, the Safari web-alert walk) only run for candidates
+// that actually matched, not for every possible type.
+- (nullable XCUIElement *)fb_alertElementWithSnapshot:(id<FBXCElementSnapshot> _Nullable * _Nullable)snapshotOut
 {
-  NSPredicate *alertCollectorPredicate = [NSPredicate predicateWithFormat:@"elementType IN {%lu,%lu,%lu}",
-                                          XCUIElementTypeAlert, XCUIElementTypeSheet, XCUIElementTypeScrollView];
-  XCUIElement *alert = [[self descendantsMatchingType:XCUIElementTypeAny]
-                        matchingPredicate:alertCollectorPredicate].allElementsBoundByIndex.firstObject;
-  if (nil == alert) {
+  NSPredicate *predicate = [NSPredicate predicateWithFormat:@"elementType IN {%lu,%lu,%lu}",
+                            XCUIElementTypeAlert, XCUIElementTypeSheet, XCUIElementTypeScrollView];
+  // allElementsBoundByAccessibilityElement resolves all matches in one
+  // round trip; allElementsBoundByIndex pays one extra round trip per
+  // match, costly while the target is JS-blocked inside alert() (~5s per
+  // hop).
+  NSArray<XCUIElement *> *candidates = [[self descendantsMatchingType:XCUIElementTypeAny]
+                                        matchingPredicate:predicate].allElementsBoundByAccessibilityElement;
+  if (0 == candidates.count) {
     return nil;
   }
-  id<FBXCElementSnapshot> alertSnapshot = alert.fb_cachedSnapshot ?: [alert fb_customSnapshot];
 
-  if (alertSnapshot.elementType == XCUIElementTypeAlert) {
-    return alert;
+  NSMutableArray<XCUIElement *> *sheets = [NSMutableArray array];
+  NSMutableArray<XCUIElement *> *scrollViews = [NSMutableArray array];
+  for (XCUIElement *candidate in candidates) {
+    switch (candidate.elementType) {
+      case XCUIElementTypeAlert:
+        return candidate;
+      case XCUIElementTypeSheet:
+        [sheets addObject:candidate];
+        break;
+      case XCUIElementTypeScrollView:
+        [scrollViews addObject:candidate];
+        break;
+      default:
+        break;
+    }
   }
 
-  if (alertSnapshot.elementType == XCUIElementTypeSheet) {
-    if ([UIDevice currentDevice].userInterfaceIdiom == UIUserInterfaceIdiomPhone) {
-      return alert;
+  BOOL isPhone = [UIDevice currentDevice].userInterfaceIdiom == UIUserInterfaceIdiomPhone;
+  for (XCUIElement *sheet in sheets) {
+    if (isPhone) {
+      return sheet;
     }
 
     // In case of iPad we want to check if sheet isn't contained by popover.
     // In that case we ignore it.
-    id<FBXCElementSnapshot> ancestor = alertSnapshot.parent;
+    id<FBXCElementSnapshot> sheetSnapshot = sheet.lastSnapshot ?: sheet.fb_cachedSnapshot ?: [sheet fb_customSnapshot];
+    BOOL isInsidePopover = NO;
+    id<FBXCElementSnapshot> ancestor = sheetSnapshot.parent;
     while (nil != ancestor) {
       if (nil != ancestor.identifier && [ancestor.identifier isEqualToString:@"PopoverDismissRegion"]) {
-        return nil;
+        isInsidePopover = YES;
+        break;
       }
       ancestor = ancestor.parent;
     }
-    return alert;
+    if (!isInsidePopover) {
+      if (NULL != snapshotOut) {
+        *snapshotOut = sheetSnapshot;
+      }
+      return sheet;
+    }
   }
 
-  if (alertSnapshot.elementType == XCUIElementTypeScrollView) {
-    id<FBXCElementSnapshot> app = [[FBXCElementSnapshotWrapper ensureWrapped:alertSnapshot] fb_parentMatchingType:XCUIElementTypeApplication];
-    if (nil != app && [app.label isEqualToString:FB_SAFARI_APP_NAME]) {
-      // Check alert presence in Safari web view
-      return [self fb_alertElementFromSafariWithScrollView:alert viewSnapshot:alertSnapshot];
+  for (XCUIElement *scrollView in scrollViews) {
+    id<FBXCElementSnapshot> scrollViewSnapshot = scrollView.lastSnapshot ?: scrollView.fb_cachedSnapshot ?: [scrollView fb_customSnapshot];
+    id<FBXCElementSnapshot> app = [[FBXCElementSnapshotWrapper ensureWrapped:scrollViewSnapshot] fb_parentMatchingType:XCUIElementTypeApplication];
+    if (nil == app || ![app.label isEqualToString:FB_SAFARI_APP_NAME]) {
+      continue;
+    }
+    // Check alert presence in Safari web view
+    id<FBXCElementSnapshot> safariAlertSnapshot = [self.class fb_findSafariAlertSnapshotInScrollView:scrollViewSnapshot];
+    if (nil != safariAlertSnapshot) {
+      // Not resolving safariAlertSnapshot to a live element here (another
+      // round trip) - scrollView is already live and is a valid ancestor
+      // for callers to resolve buttons/fields from later.
+      if (NULL != snapshotOut) {
+        *snapshotOut = safariAlertSnapshot;
+      }
+      return scrollView;
     }
   }
 

package/WebDriverAgentLib/Categories/XCUIApplication+FBHelpers.h

@@ -8,6 +8,8 @@
 
 #import <XCTest/XCTest.h>
 
+#import "FBXCElementSnapshot.h"
+
 @class XCElementSnapshot;
 @protocol FBXCAccessibilityElement;
 @class FBXMLGenerationOptions;
@@ -166,6 +168,19 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (BOOL)fb_isSameAppAs:(nullable XCUIApplication *)otherApp;
 
+/**
+ Resolves the live element that corresponds to an already-known snapshot
+ found somewhere under rootElement, by matching on its stable uid, instead
+ of re-running a fresh attribute/type-based query - a single targeted
+ accessibility round trip regardless of how deep the snapshot sits.
+
+ @param snapshot The snapshot to resolve a live element for
+ @param rootElement The element to scope the uid lookup query to
+ @return The live element matching the snapshot's uid, or nil if it could not be resolved
+ */
++ (nullable XCUIElement *)fb_elementForSnapshot:(id<FBXCElementSnapshot>)snapshot
+                                    underElement:(XCUIElement *)rootElement;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/WebDriverAgentLib/Categories/XCUIApplication+FBHelpers.m

@@ -33,6 +33,7 @@
 #import "XCUIElement.h"
 #import "XCUIElement+FBCaching.h"
 #import "XCUIElement+FBIsVisible.h"
+#import "XCUIElement+FBUID.h"
 #import "XCUIElement+FBUtilities.h"
 #import "XCUIElement+FBWebDriverAttributes.h"
 #import "XCUIElementQuery.h"
@@ -653,4 +654,19 @@ NSDictionary<NSString *, NSString *> *customExclusionAttributesMap(void) {
   return self == otherApp || [self.bundleID isEqualToString:(NSString *)otherApp.bundleID];
 }
 
++ (nullable XCUIElement *)fb_elementForSnapshot:(id<FBXCElementSnapshot>)snapshot
+                                    underElement:(XCUIElement *)rootElement
+{
+  NSString *uid = [FBXCElementSnapshotWrapper wdUIDWithSnapshot:snapshot];
+  if (nil == uid) {
+    return nil;
+  }
+  NSPredicate *predicate = [NSPredicate predicateWithFormat:@"%K = %@",
+                             FBStringify(FBXCElementSnapshotWrapper, fb_uid), uid];
+  // Filtering by the snapshot's own type (instead of XCUIElementTypeAny) lets
+  // the query narrow down before the uid predicate is even applied.
+  return [[rootElement.fb_query descendantsMatchingType:snapshot.elementType]
+          matchingPredicate:predicate].allElementsBoundByIndex.firstObject;
+}
+
 @end

package/WebDriverAgentLib/Categories/XCUIElement+FBClassChain.m

@@ -11,6 +11,7 @@
 #import "FBClassChainQueryParser.h"
 #import "FBXCodeCompatibility.h"
 #import "FBExceptions.h"
+#import "XCUIElement+FBUtilities.h"
 
 @implementation XCUIElement (FBClassChain)
 
@@ -22,7 +23,39 @@
     @throw [NSException exceptionWithName:FBClassChainQueryParseException reason:error.localizedDescription userInfo:error.userInfo];
     return nil;
   }
-  NSMutableArray<FBClassChainItem *> *lookupChain = parsedChain.elements.mutableCopy;
+  // The snapshot-walk strategy below only pays off when an intermediate
+  // (non-final) segment carries an explicit position: that is the only
+  // shape where the query-based strategy has to resolve a live element
+  // mid-chain - and pay an accessibility round trip - just to keep building
+  // the next segment's query. Every other shape (including the common case
+  // of zero or one position, on the final segment only) already resolves in
+  // a single round trip with the query-based strategy, while the snapshot
+  // walk always pays for one full upfront subtree snapshot regardless of
+  // whether it is actually needed - a bad trade in deep/large trees. See
+  // https://github.com/appium/WebDriverAgent/pull/1194#issuecomment-5156633352
+  NSArray<FBClassChainItem *> *chainItems = parsedChain.elements;
+  return [self.class fb_hasIntermediatePosition:chainItems]
+    ? [self fb_snapshotDescendantsMatchingChainItems:chainItems shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch]
+    : [self fb_queryDescendantsMatchingChainItems:chainItems shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch];
+}
+
++ (BOOL)fb_hasIntermediatePosition:(NSArray<FBClassChainItem *> *)chainItems
+{
+  for (NSUInteger i = 0; i + 1 < chainItems.count; i++) {
+    if (nil != chainItems[i].position) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+#pragma mark - Query-based strategy
+#pragma mark (single accessibility round trip; used whenever no intermediate
+#pragma mark  segment carries an explicit position)
+
+- (NSArray<XCUIElement *> *)fb_queryDescendantsMatchingChainItems:(NSArray<FBClassChainItem *> *)chainItems shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
+{
+  NSMutableArray<FBClassChainItem *> *lookupChain = chainItems.mutableCopy;
   FBClassChainItem *chainItem = lookupChain.firstObject;
   XCUIElement *currentRoot = self;
   XCUIElementQuery *query = [currentRoot fb_queryWithChainItem:chainItem query:nil];
@@ -30,8 +63,6 @@
   while (lookupChain.count > 0) {
     BOOL isRootChanged = NO;
     if (nil != chainItem.position) {
-      // It is necessary to resolve the query if intermediate element index is not zero or one,
-      // because predicates don't support search by indexes
       NSArray<XCUIElement *> *currentRootMatch = [self.class fb_matchingElementsWithItem:chainItem
                                                                                    query:query
                                                              shouldReturnAfterFirstMatch:nil];
@@ -95,4 +126,116 @@
   return @[];
 }
 
+#pragma mark - Snapshot-based strategy
+#pragma mark (single upfront snapshot walked in memory; used when an
+#pragma mark  intermediate segment has an explicit position, avoiding one
+#pragma mark  extra accessibility round trip per such segment)
+
+- (NSArray<XCUIElement *> *)fb_snapshotDescendantsMatchingChainItems:(NSArray<FBClassChainItem *> *)chainItems shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
+{
+  NSMutableArray<FBClassChainItem *> *lookupChain = chainItems.mutableCopy;
+  // Reuse an already-taken snapshot of `self` if one is available (e.g. the
+  // caller just resolved/inspected this same element) instead of always
+  // paying for a fresh one.
+  NSArray<id<FBXCElementSnapshot>> *currentRoots = @[self.lastSnapshot ?: [self fb_customSnapshot]];
+  FBClassChainItem *chainItem = lookupChain.firstObject;
+  NSArray<id<FBXCElementSnapshot>> *candidates = [self.class fb_snapshotsMatchingItem:chainItem inRoots:currentRoots];
+  [lookupChain removeObjectAtIndex:0];
+  while (lookupChain.count > 0) {
+    if (nil != chainItem.position) {
+      // An explicit position always narrows the match set down to a single
+      // element, which becomes the sole root for the rest of the chain, so
+      // it has to be resolved now instead of being folded into `candidates`
+      // like an unindexed segment would be
+      NSArray<id<FBXCElementSnapshot>> *currentRootMatch = [self.class fb_matchingSnapshotsWithItem:chainItem
+                                                                                           candidates:candidates
+                                                                          shouldReturnAfterFirstMatch:nil];
+      if (0 == currentRootMatch.count) {
+        return @[];
+      }
+      currentRoots = @[currentRootMatch.firstObject];
+    } else {
+      currentRoots = candidates;
+    }
+    chainItem = lookupChain.firstObject;
+    candidates = [self.class fb_snapshotsMatchingItem:chainItem inRoots:currentRoots];
+    [lookupChain removeObjectAtIndex:0];
+  }
+  NSArray<id<FBXCElementSnapshot>> *matchedSnapshots = [self.class fb_matchingSnapshotsWithItem:chainItem
+                                                                                      candidates:candidates
+                                                                     shouldReturnAfterFirstMatch:@(shouldReturnAfterFirstMatch)];
+  return [self fb_filterDescendantsWithSnapshots:matchedSnapshots onlyChildren:NO];
+}
+
++ (NSArray<id<FBXCElementSnapshot>> *)fb_snapshotsMatchingItem:(FBClassChainItem *)item inRoots:(NSArray<id<FBXCElementSnapshot>> *)roots
+{
+  NSMutableArray<id<FBXCElementSnapshot>> *typeMatches = [NSMutableArray array];
+  for (id<FBXCElementSnapshot> root in roots) {
+    if (item.isDescendant) {
+      // descendantsByFilteringWithBlock: includes the receiver itself if it
+      // matches the filter, unlike XCUIElementQuery's descendantsMatchingType:,
+      // so the root has to be excluded explicitly here.
+      [typeMatches addObjectsFromArray:[root descendantsByFilteringWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot) {
+        return snapshot != root && (item.type == XCUIElementTypeAny || snapshot.elementType == item.type);
+      }]];
+    } else {
+      for (id<FBXCElementSnapshot> child in root.children) {
+        if (item.type == XCUIElementTypeAny || child.elementType == item.type) {
+          [typeMatches addObject:child];
+        }
+      }
+    }
+  }
+  if (roots.count > 1) {
+    // Overlapping roots (e.g. a previous segment matched both an ancestor
+    // and its own descendant) can otherwise yield the same snapshot twice,
+    // which would skew positional selection ([2], [-1], etc.) compared to
+    // the XCUIElementQuery-based matching this replaced, which always
+    // operated on a de-duplicated element set.
+    NSMutableArray<id<FBXCElementSnapshot>> *dedupedMatches = [NSMutableArray arrayWithCapacity:typeMatches.count];
+    NSHashTable<id<FBXCElementSnapshot>> *seenMatches = [NSHashTable hashTableWithOptions:NSHashTableObjectPointerPersonality];
+    for (id<FBXCElementSnapshot> match in typeMatches) {
+      if (![seenMatches containsObject:match]) {
+        [seenMatches addObject:match];
+        [dedupedMatches addObject:match];
+      }
+    }
+    typeMatches = dedupedMatches;
+  }
+  for (FBAbstractPredicateItem *predicateItem in item.predicates) {
+    if ([predicateItem isKindOfClass:FBSelfPredicateItem.class]) {
+      typeMatches = [[typeMatches filteredArrayUsingPredicate:predicateItem.value] mutableCopy];
+    } else if ([predicateItem isKindOfClass:FBDescendantPredicateItem.class]) {
+      NSMutableArray<id<FBXCElementSnapshot>> *containingMatches = [NSMutableArray array];
+      for (id<FBXCElementSnapshot> candidate in typeMatches) {
+        NSArray<id<FBXCElementSnapshot>> *matchingDescendants = [candidate descendantsByFilteringWithBlock:^BOOL(id<FBXCElementSnapshot> descendant) {
+          return descendant != candidate && [predicateItem.value evaluateWithObject:descendant];
+        }];
+        if (matchingDescendants.count > 0) {
+          [containingMatches addObject:candidate];
+        }
+      }
+      typeMatches = containingMatches;
+    }
+  }
+  return typeMatches.copy;
+}
+
++ (NSArray<id<FBXCElementSnapshot>> *)fb_matchingSnapshotsWithItem:(FBClassChainItem *)item candidates:(NSArray<id<FBXCElementSnapshot>> *)candidates shouldReturnAfterFirstMatch:(nullable NSNumber *)shouldReturnAfterFirstMatch
+{
+  if (1 == item.position.integerValue || (0 == item.position.integerValue && shouldReturnAfterFirstMatch.boolValue)) {
+    id<FBXCElementSnapshot> result = candidates.firstObject;
+    return result ? @[result] : @[];
+  }
+  if (0 == item.position.integerValue) {
+    return candidates;
+  }
+  if (candidates.count >= (NSUInteger)ABS(item.position.integerValue)) {
+    return item.position.integerValue > 0
+      ? @[[candidates objectAtIndex:item.position.integerValue - 1]]
+      : @[[candidates objectAtIndex:candidates.count + item.position.integerValue]];
+  }
+  return @[];
+}
+
 @end

package/WebDriverAgentLib/Commands/FBAlertViewCommands.m

@@ -54,19 +54,11 @@
     return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:@"Missing 'value' parameter" traceback:nil]);
   }
   FBAlert *alert = [FBAlert alertWithApplication:session.activeApplication];
-  if (!alert.isPresent) {
-    return FBResponseWithStatus([FBCommandStatus noAlertOpenErrorWithMessage:nil
-                                                                   traceback:nil]);
-  }
   NSString *textToType = value;
   if ([value isKindOfClass:[NSArray class]]) {
     textToType = [value componentsJoinedByString:@""];
   }
-  NSError *error;
-  if (![alert typeText:textToType error:&error]) {
-    return FBResponseWithStatus([FBCommandStatus unsupportedOperationErrorWithMessage:error.description
-                                                                            traceback:[NSString stringWithFormat:@"%@", NSThread.callStackSymbols]]);
-  }
+  [alert typeText:textToType];
   return FBResponseWithOK();
 }
 
@@ -75,20 +67,11 @@
   XCUIApplication *application = request.session.activeApplication ?: XCUIApplication.fb_activeApplication;
   NSString *name = request.arguments[@"name"];
   FBAlert *alert = [FBAlert alertWithApplication:application];
-  NSError *error;
 
-  if (!alert.isPresent) {
-    return FBResponseWithStatus([FBCommandStatus noAlertOpenErrorWithMessage:nil
-                                                                   traceback:nil]);
-  }
   if (name) {
-    if (![alert clickAlertButton:name error:&error]) {
-      return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description
-                                                                             traceback:[NSString stringWithFormat:@"%@", NSThread.callStackSymbols]]);
-    }
-  } else if (![alert acceptWithError:&error]) {
-    return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description
-                                                                            traceback:[NSString stringWithFormat:@"%@", NSThread.callStackSymbols]]);
+    [alert clickAlertButton:name];
+  } else {
+    [alert accept];
   }
   return FBResponseWithOK();
 }
@@ -98,20 +81,11 @@
   XCUIApplication *application = request.session.activeApplication ?: XCUIApplication.fb_activeApplication;
   NSString *name = request.arguments[@"name"];
   FBAlert *alert = [FBAlert alertWithApplication:application];
-  NSError *error;
-    
-  if (!alert.isPresent) {
-    return FBResponseWithStatus([FBCommandStatus noAlertOpenErrorWithMessage:nil
-                                                                   traceback:nil]);
-  }
+
   if (name) {
-    if (![alert clickAlertButton:name error:&error]) {
-      return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description
-                                                                            traceback:[NSString stringWithFormat:@"%@", NSThread.callStackSymbols]]);
-    }
-  } else if (![alert dismissWithError:&error]) {
-    return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description
-                                                                            traceback:[NSString stringWithFormat:@"%@", NSThread.callStackSymbols]]);
+    [alert clickAlertButton:name];
+  } else {
+    [alert dismiss];
   }
   return FBResponseWithOK();
 }
@@ -120,11 +94,11 @@
   FBSession *session = request.session;
   FBAlert *alert = [FBAlert alertWithApplication:session.activeApplication];
 
-  if (!alert.isPresent) {
+  NSArray *labels = alert.buttonLabels;
+  if (!labels) {
     return FBResponseWithStatus([FBCommandStatus noAlertOpenErrorWithMessage:nil
                                                                    traceback:nil]);
   }
-  NSArray *labels = alert.buttonLabels;
   return FBResponseWithObject(labels);
 }
 @end