@devicelab/maestro-runner-darwin-arm64 1.1.25 → 1.1.28

package/drivers/ios/WebDriverAgent/WebDriverAgent.xcodeproj/xcshareddata/xcschemes/WebDriverAgentRunner_watchOS.xcscheme

@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "2600"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "C0A58256FB8AD3E976C8F8D2"
+               BuildableName = "WebDriverAgentRunner_watchOS.xctest"
+               BlueprintName = "WebDriverAgentRunner_watchOS"
+               ReferencedContainer = "container:WebDriverAgent.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = ""
+      selectedLauncherIdentifier = "Xcode.IDEFoundation.Launcher.PosixSpawn"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      systemAttachmentLifetime = "keepNever">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "C0A58256FB8AD3E976C8F8D2"
+            BuildableName = "WebDriverAgentRunner_watchOS.xctest"
+            BlueprintName = "WebDriverAgentRunner_watchOS"
+            ReferencedContainer = "container:WebDriverAgent.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "C0A58256FB8AD3E976C8F8D2"
+               BuildableName = "WebDriverAgentRunner_watchOS.xctest"
+               BlueprintName = "WebDriverAgentRunner_watchOS"
+               ReferencedContainer = "container:WebDriverAgent.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "C0A58256FB8AD3E976C8F8D2"
+            BuildableName = "WebDriverAgentRunner_watchOS.xctest"
+            BlueprintName = "WebDriverAgentRunner_watchOS"
+            ReferencedContainer = "container:WebDriverAgent.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "USE_PORT"
+            value = "$(USE_PORT)"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+         <EnvironmentVariable
+            key = "USE_IP"
+            value = "$(USE_IP)"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+         <EnvironmentVariable
+            key = "UPGRADE_TIMESTAMP"
+            value = "$(UPGRADE_TIMESTAMP)"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+         <EnvironmentVariable
+            key = "WDA_PRODUCT_BUNDLE_IDENTIFIER"
+            value = "$(WDA_PRODUCT_BUNDLE_IDENTIFIER)"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+         <EnvironmentVariable
+            key = "MAX_HTTP_REQUEST_BODY_SIZE"
+            value = "$(MAX_HTTP_REQUEST_BODY_SIZE)"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+         <EnvironmentVariable
+            key = "VERBOSE_LOGGING"
+            value = "$(VERBOSE_LOGGING)"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "C0A58256FB8AD3E976C8F8D2"
+            BuildableName = "WebDriverAgentRunner_watchOS.xctest"
+            BlueprintName = "WebDriverAgentRunner_watchOS"
+            ReferencedContainer = "container:WebDriverAgent.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/NSDictionary+FBUtf8SafeDictionary.m

@@ -14,32 +14,42 @@ const unichar REPLACER = 0xfffd;
 
 - (instancetype)fb_utf8SafeStringWithReplacement:(unichar)replacement
 {
-  if ([self canBeConvertedToEncoding:NSUTF8StringEncoding]) {
-    return self;
-  }
-
-  NSData *data = [self dataUsingEncoding:NSUTF8StringEncoding allowLossyConversion:YES];
-  NSString *convertedString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
-  NSMutableString *result = [NSMutableString string];
-  NSString *replacementStr = [NSString stringWithCharacters:&replacement length:1];
-  NSUInteger originalIdx = 0;
-  NSUInteger convertedIdx = 0;
-  while (originalIdx < [self length] && convertedIdx < [convertedString length]) {
-    unichar originalChar = [self characterAtIndex:originalIdx];
-    unichar convertedChar = [convertedString characterAtIndex:convertedIdx];
-
-    if (originalChar == convertedChar) {
-      [result appendString:[NSString stringWithCharacters:&originalChar length:1]];
-      originalIdx++;
-      convertedIdx++;
+  // -canBeConvertedToEncoding: and -dataUsingEncoding:allowLossyConversion:
+  // both misreport strings containing unpaired UTF-16 surrogates, so the
+  // code units are validated manually instead of relying on them.
+  NSUInteger length = self.length;
+  NSMutableString *result = nil;
+  NSString *replacementStr = nil;
+  NSUInteger copiedIdx = 0;
+  NSUInteger idx = 0;
+  while (idx < length) {
+    unichar c = [self characterAtIndex:idx];
+    if (c >= 0xD800 && c <= 0xDBFF && idx + 1 < length) {
+      unichar next = [self characterAtIndex:idx + 1];
+      if (next >= 0xDC00 && next <= 0xDFFF) {
+        idx += 2;
+        continue;
+      }
+    }
+    if (c < 0xD800 || c > 0xDFFF) {
+      idx += 1;
       continue;
     }
-
-    while (originalChar != convertedChar && originalIdx < [self length]) {
-      [result appendString:replacementStr];
-      originalChar = [self characterAtIndex:++originalIdx];
+    // Unpaired surrogate found. Lazily allocate the result and copy over
+    // the valid run preceding it, so strings without any are returned as-is.
+    if (nil == result) {
+      result = [NSMutableString stringWithCapacity:length];
+      replacementStr = [NSString stringWithCharacters:&replacement length:1];
     }
+    [result appendString:[self substringWithRange:NSMakeRange(copiedIdx, idx - copiedIdx)]];
+    [result appendString:replacementStr];
+    idx += 1;
+    copiedIdx = idx;
+  }
+  if (nil == result) {
+    return self;
   }
+  [result appendString:[self substringWithRange:NSMakeRange(copiedIdx, length - copiedIdx)]];
   return result.copy;
 }
 
@@ -70,16 +80,24 @@ const unichar REPLACER = 0xfffd;
 
 - (instancetype)fb_utf8SafeDictionary
 {
-  NSMutableDictionary *result = [self mutableCopy];
+  NSMutableDictionary *result = [NSMutableDictionary dictionaryWithCapacity:self.count];
   for (id key in self) {
-    id value = result[key];
+    id value = self[key];
+    id safeValue = value;
     if ([value isKindOfClass:NSString.class]) {
-      result[key] = [(NSString *)value fb_utf8SafeStringWithReplacement:REPLACER];
+      safeValue = [(NSString *)value fb_utf8SafeStringWithReplacement:REPLACER];
     } else if ([value isKindOfClass:NSArray.class]) {
-      result[key] = [(NSArray *)value fb_utf8SafeArray];
+      safeValue = [(NSArray *)value fb_utf8SafeArray];
     } else if ([value isKindOfClass:NSDictionary.class]) {
-      result[key] = [(NSDictionary *)value fb_utf8SafeDictionary];
+      safeValue = [(NSDictionary *)value fb_utf8SafeDictionary];
     }
+    // Sanitized keys could theoretically collide (e.g. two distinct invalid
+    // keys both reducing to the same replacement string); the later one
+    // wins, same as any other NSDictionary literal with duplicate keys.
+    id safeKey = [key isKindOfClass:NSString.class]
+      ? [(NSString *)key fb_utf8SafeStringWithReplacement:REPLACER]
+      : key;
+    result[safeKey] = safeValue;
   }
   return result.copy;
 }

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCAXClient_iOS+FBSnapshotReqParams.h

@@ -12,6 +12,7 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+extern NSString *const FBSnapshotMaxChildrenKey;
 extern NSString *const FBSnapshotMaxDepthKey;
 
 void FBSetCustomParameterForElementSnapshot (NSString* name, id value);

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCAXClient_iOS+FBSnapshotReqParams.m

@@ -10,6 +10,13 @@
 
 #import <objc/runtime.h>
 
+#import "FBConfiguration.h"
+#import "FBErrorBuilder.h"
+#import "FBLogger.h"
+#import "FBXCAccessibilityElement.h"
+#import "FBXCAXClientProxy.h"
+#import "XCUIApplication.h"
+
 /**
  Available parameters with their default values for XCTest:
   @"maxChildren" : (int)2147483647
@@ -19,6 +26,7 @@
   @"maxDepth" : (int)2147483647
  */
 NSString *const FBSnapshotMaxDepthKey = @"maxDepth";
+NSString *const FBSnapshotMaxChildrenKey = @"maxChildren";
 
 static id (*original_defaultParameters)(id, SEL);
 static id (*original_snapshotParameters)(id, SEL);
@@ -59,6 +67,82 @@ static id swizzledSnapshotParameters(id self, SEL _cmd)
   return result;
 }
 
+static id (*original_requestSnapshotForElement)(id, SEL, id, id, id, NSError **);
+
+// pid -> last-unresponsive-at. XCTest retries a failed snapshot request several
+// times in a row; this lets retries fail fast within `timeout` of the last check
+// instead of each re-running the full wait.
+static NSMutableDictionary<NSNumber *, NSDate *> *unresponsiveApplicationPids;
+static NSObject *unresponsiveApplicationPidsLock;
+
+static NSError *FBBuildUnresponsiveApplicationError(int pid, NSTimeInterval timeout)
+{
+  // https://github.com/appium/WebDriverAgent/issues/1210
+  NSString *description = [NSString stringWithFormat:
+    @"The application with process identifier %d did not confirm its main run loop is "
+     @"responsive within %.1f second(s) and is likely in an unresponsive state. "
+     @"Aborting the accessibility snapshot request instead of risking an indefinite "
+     @"hang.",
+    pid, timeout];
+  [FBLogger logFmt:@"%@", description];
+  NSError *error;
+  [[[FBErrorBuilder builder] withDescription:description] buildError:&error];
+  return error;
+}
+
+// Guards -[XCAXClient_iOS requestSnapshotForElement:...] against hanging forever
+// on an unresponsive app (#1210). If accessibilityDeadline > 0, checks run loop
+// responsiveness first and aborts with an error instead of risking an unbounded
+// wait; otherwise falls through to the original, unbounded behavior.
+static id swizzledRequestSnapshotForElement(id self, SEL _cmd, id element, id attributes, id parameters, NSError **error)
+{
+  NSTimeInterval timeout = FBConfiguration.sharedInstance.accessibilityDeadline;
+  if (timeout < DBL_EPSILON) {
+    return original_requestSnapshotForElement(self, _cmd, element, attributes, parameters, error);
+  }
+
+  int pid = [(id<FBXCAccessibilityElement>)element processIdentifier];
+  XCUIApplication *application = [FBXCAXClientProxy.sharedClient monitoredApplicationWithProcessIdentifier:pid];
+  if (nil == application) {
+    // Nothing to confirm responsiveness for (e.g. the system element) - fall
+    // through to the original behavior.
+    return original_requestSnapshotForElement(self, _cmd, element, attributes, parameters, error);
+  }
+
+  NSNumber *pidKey = @(pid);
+  @synchronized (unresponsiveApplicationPidsLock) {
+    NSDate *markedUnresponsiveAt = unresponsiveApplicationPids[pidKey];
+    if (nil != markedUnresponsiveAt && -markedUnresponsiveAt.timeIntervalSinceNow < timeout) {
+      if (nil != error) {
+        *error = FBBuildUnresponsiveApplicationError(pid, timeout);
+      }
+      return nil;
+    }
+  }
+
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+  __block BOOL isResponsive = NO;
+  [FBXCAXClientProxy.sharedClient notifyWhenEventLoopIsIdleForApplication:application
+                                                                     reply:^(id result, NSError *idleError) {
+    isResponsive = (nil == idleError);
+    dispatch_semaphore_signal(sem);
+  }];
+  BOOL didReplyInTime = 0 == dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, (int64_t)(timeout * NSEC_PER_SEC)));
+  if (didReplyInTime && isResponsive) {
+    @synchronized (unresponsiveApplicationPidsLock) {
+      [unresponsiveApplicationPids removeObjectForKey:pidKey];
+    }
+    return original_requestSnapshotForElement(self, _cmd, element, attributes, parameters, error);
+  }
+
+  @synchronized (unresponsiveApplicationPidsLock) {
+    unresponsiveApplicationPids[pidKey] = [NSDate date];
+  }
+  if (nil != error) {
+    *error = FBBuildUnresponsiveApplicationError(pid, timeout);
+  }
+  return nil;
+}
 
 @implementation XCAXClient_iOS (FBSnapshotReqParams)
 
@@ -68,6 +152,9 @@ static id swizzledSnapshotParameters(id self, SEL _cmd)
 
 + (void)load
 {
+  unresponsiveApplicationPids = [NSMutableDictionary new];
+  unresponsiveApplicationPidsLock = [NSObject new];
+
   Method original_defaultParametersMethod = class_getInstanceMethod(self.class, @selector(defaultParameters));
   IMP swizzledDefaultParametersImp = (IMP)swizzledDefaultParameters;
   original_defaultParameters = (id (*)(id, SEL)) method_setImplementation(original_defaultParametersMethod, swizzledDefaultParametersImp);
@@ -75,6 +162,10 @@ static id swizzledSnapshotParameters(id self, SEL _cmd)
   Method original_snapshotParametersMethod = class_getInstanceMethod(NSClassFromString(@"XCTElementQuery"), NSSelectorFromString(@"snapshotParameters"));
   IMP swizzledSnapshotParametersImp = (IMP)swizzledSnapshotParameters;
   original_snapshotParameters = (id (*)(id, SEL)) method_setImplementation(original_snapshotParametersMethod, swizzledSnapshotParametersImp);
+
+  Method original_requestSnapshotForElementMethod = class_getInstanceMethod(self.class, @selector(requestSnapshotForElement:attributes:parameters:error:));
+  IMP swizzledRequestSnapshotForElementImp = (IMP)swizzledRequestSnapshotForElement;
+  original_requestSnapshotForElement = (id (*)(id, SEL, id, id, id, NSError **)) method_setImplementation(original_requestSnapshotForElementMethod, swizzledRequestSnapshotForElementImp);
 }
 
 #pragma clang diagnostic pop

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIApplication+FBAlert.h

@@ -8,16 +8,40 @@
 
 #import <XCTest/XCTest.h>
 
+#import "FBXCElementSnapshot.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
 @interface XCUIApplication (FBAlert)
 
 /* The accessiblity label used for Safari app */
 extern NSString *const FB_SAFARI_APP_NAME;
 
 /**
- Retrieve the current alert element
+ 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.
 
- @return Alert element instance
+ @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
  */
-- (XCUIElement *)fb_alertElement;
+- (nullable XCUIElement *)fb_alertElementWithSnapshot:(id<FBXCElementSnapshot> _Nullable * _Nullable)snapshotOut;
+
+/**
+ 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 The prompt application if it is running in the foreground, otherwise nil
+ */
++ (nullable XCUIApplication *)fb_limitedAccessPromptApplication;
 
 @end
+
+NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/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"
@@ -17,89 +16,160 @@
 
 NSString *const FB_SAFARI_APP_NAME = @"Safari";
 
+// The iOS 18+ limited access permission prompt (e.g. the "Select Contacts" view)
+// runs in a dedicated process that is not reported by fb_activeApplications.
+static NSString *const FB_LIMITED_ACCESS_PROMPT_BUNDLE_ID = @"com.apple.ContactsUI.LimitedAccessPromptView";
+
 
 @implementation XCUIApplication (FBAlert)
 
-- (nullable XCUIElement *)fb_alertElementFromSafariWithScrollView:(XCUIElement *)scrollView
-                                                     viewSnapshot:(id<FBXCElementSnapshot>)viewSnapshot
++ (nullable XCUIApplication *)fb_limitedAccessPromptApplication
+{
+  XCUIApplication *promptApp = [[XCUIApplication alloc] initWithBundleIdentifier:FB_LIMITED_ACCESS_PROMPT_BUNDLE_ID];
+  return promptApp.state < XCUIApplicationStateRunningForeground ? nil : promptApp;
+}
+
++ (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) {
+    XCUIElementType elementType = candidate.elementType;
+    if (elementType == XCUIElementTypeAlert) {
+      return candidate;
+    } else if (elementType == XCUIElementTypeSheet) {
+      [sheets addObject:candidate];
+    } else if (elementType == XCUIElementTypeScrollView) {
+      [scrollViews addObject:candidate];
+    }
   }
 
-  if (alertSnapshot.elementType == XCUIElementTypeSheet) {
-    if ([UIDevice currentDevice].userInterfaceIdiom == UIUserInterfaceIdiomPhone) {
-      return alert;
+#if TARGET_OS_WATCH
+  // No popover concept or UIUserInterfaceIdiom on watchOS - treat sheets like phone sheets.
+  BOOL isPhone = YES;
+#else
+  BOOL isPhone = [UIDevice currentDevice].userInterfaceIdiom == UIUserInterfaceIdiomPhone;
+#endif
+  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.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.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/drivers/ios/WebDriverAgent/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