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

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBScrolling.m

@@ -16,6 +16,8 @@
 #import "FBXCElementSnapshotWrapper.h"
 #import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIElement+FBCaching.h"
+#import "XCUIElement+FBResolve.h"
+#import "XCUIElement+FBUID.h"
 #import "XCUIApplication.h"
 #import "XCUICoordinate.h"
 #import "XCUIElement+FBIsVisible.h"
@@ -35,50 +37,76 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
 @interface FBXCElementSnapshotWrapper (FBScrolling)
 
-- (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
-- (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
-- (void)fb_scrollLeftByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
-- (void)fb_scrollRightByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
-- (BOOL)fb_scrollByNormalizedVector:(CGVector)normalizedScrollVector inApplication:(XCUIApplication *)application;
-- (BOOL)fb_scrollByVector:(CGVector)vector inApplication:(XCUIApplication *)application error:(NSError **)error;
+- (BOOL)fb_scrollUpByNormalizedDistance:(CGFloat)distance anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollDownByNormalizedDistance:(CGFloat)distance anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollLeftByNormalizedDistance:(CGFloat)distance anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollRightByNormalizedDistance:(CGFloat)distance anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollByNormalizedVector:(CGVector)normalizedScrollVector anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollByVector:(CGVector)vector anchorElement:(XCUIElement *)anchorElement error:(NSError **)error;
 
 @end
 
+/**
+ Resolves a live element for the given snapshot, so gesture coordinates can be anchored
+ to it (its frame gets rescaled by XCTest for compatibility-mode windows; a raw
+ XCUIApplication anchor never does - see appium/appium#16185). Returns nil, rather than
+ falling back to the application, if the snapshot can no longer be located: anchoring to
+ the application would silently reproduce the very bug this is fixing.
+ */
+static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, XCUIApplication *application)
+{
+  NSString *uid = [FBXCElementSnapshotWrapper wdUIDWithSnapshot:snapshot];
+  if (nil == uid) {
+    return nil;
+  }
+  XCUIElement *result;
+  @autoreleasepool {
+    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"%K = %@", FBStringify(FBXCElementSnapshotWrapper, fb_uid), uid];
+    result = [[application.fb_query descendantsMatchingType:XCUIElementTypeAny] matchingPredicate:predicate].allElementsBoundByIndex.firstObject;
+  }
+  result.fb_isResolvedNatively = @NO;
+  return result;
+}
+
 @implementation XCUIElement (FBScrolling)
 
 - (BOOL)fb_nativeScrollToVisibleWithError:(NSError **)error
 {
-  id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
-  return nil != [self _hitPointByAttemptingToScrollToVisibleSnapshot:snapshot
-                                                               error:error];
+  [self scrollToVisible];
+  if (self.wdVisible) {
+    return YES;
+  }
+  return [[[FBErrorBuilder builder]
+           withDescriptionFormat:@"Failed to scroll element '%@' into view", self.description]
+          buildError:error];
 }
 
 - (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance
 {
   id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
   [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollUpByNormalizedDistance:distance
-                                                                         inApplication:self.application];
+                                                                         anchorElement:self];
 }
 
 - (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance
 {
   id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
   [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollDownByNormalizedDistance:distance
-                                                                           inApplication:self.application];
+                                                                           anchorElement:self];
 }
 
 - (void)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
 {
   id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
   [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollLeftByNormalizedDistance:distance
-                                                                           inApplication:self.application];
+                                                                           anchorElement:self];
 }
 
 - (void)fb_scrollRightByNormalizedDistance:(CGFloat)distance
 {
   id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
   [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollRightByNormalizedDistance:distance
-                                                                            inApplication:self.application];
+                                                                            anchorElement:self];
 }
 
 - (BOOL)fb_scrollToVisibleWithError:(NSError **)error
@@ -172,29 +200,51 @@ const CGFloat FBScrollTouchProportion = 0.75f;
     }
   }
 
+  // The scroll view's own identity is stable across scroll steps, so it only needs
+  // to be resolved to a live element once, up front; its frame does not, since it can
+  // change across scroll steps (rotation, keyboard, dynamic layout).
+  XCUIElement *scrollViewElement = FBLiveElementForSnapshot(scrollView, self.application);
+  if (nil == scrollViewElement) {
+    return
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"Failed to resolve a live element for the scrollable parent of '%@'", self.description]
+     buildError:error];
+  }
+
   const NSUInteger maxScrollCount = 25;
   NSUInteger scrollCount = 0;
-  FBXCElementSnapshotWrapper *scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:scrollView];
+  FBXCElementSnapshotWrapper *scrollViewWrapped;
   // Scrolling till cell is visible and get current value of frames
   while (![self fb_isEquivalentElementSnapshotVisible:prescrollSnapshot] && scrollCount < maxScrollCount) {
+    BOOL didScroll;
     @autoreleasepool {
+      // Re-snapshotting the scroll view every step keeps its frame from drifting too far
+      // out of sync with the live anchor element's frame used to resolve touch points.
+      scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:[scrollViewElement fb_customSnapshot]];
       if (targetCellIndex < visibleCellIndex) {
-        scrollDirection == FBXCUIElementScrollDirectionVertical ?
+        didScroll = scrollDirection == FBXCUIElementScrollDirectionVertical ?
           [scrollViewWrapped fb_scrollUpByNormalizedDistance:normalizedScrollDistance
-                                               inApplication:self.application] :
+                                                anchorElement:scrollViewElement] :
           [scrollViewWrapped fb_scrollLeftByNormalizedDistance:normalizedScrollDistance
-                                                 inApplication:self.application];
+                                                  anchorElement:scrollViewElement];
       }
       else {
-        scrollDirection == FBXCUIElementScrollDirectionVertical ?
+        didScroll = scrollDirection == FBXCUIElementScrollDirectionVertical ?
           [scrollViewWrapped fb_scrollDownByNormalizedDistance:normalizedScrollDistance
-                                                 inApplication:self.application] :
+                                                  anchorElement:scrollViewElement] :
           [scrollViewWrapped fb_scrollRightByNormalizedDistance:normalizedScrollDistance
-                                                  inApplication:self.application];
+                                                   anchorElement:scrollViewElement];
       }
       scrollCount++;
       // Wait for scroll animation
-      [self fb_waitUntilStableWithTimeout:FBConfiguration.animationCoolOffTimeout];
+      [self fb_waitUntilStableWithTimeout:FBConfiguration.sharedInstance.animationCoolOffTimeout];
+    }
+    // The `error` out-param must not be written from inside the autorelease pool above.
+    if (!didScroll) {
+      return
+      [[[FBErrorBuilder builder]
+        withDescriptionFormat:@"Failed to scroll '%@': its frame is empty", self.description]
+       buildError:error];
     }
   }
 
@@ -211,12 +261,13 @@ const CGFloat FBScrollTouchProportion = 0.75f;
   FBXCElementSnapshotWrapper *targetCellSnapshotWrapped = [FBXCElementSnapshotWrapper ensureWrapped:[self fb_customSnapshot]];
   targetCellSnapshot = [targetCellSnapshotWrapped fb_parentCellSnapshot];
   CGRect visibleFrame = [FBXCElementSnapshotWrapper ensureWrapped:targetCellSnapshot].fb_visibleFrame;
-  
+
   CGVector scrollVector = CGVectorMake(visibleFrame.size.width - targetCellSnapshot.frame.size.width,
                                        visibleFrame.size.height - targetCellSnapshot.frame.size.height
                                        );
+  scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:[scrollViewElement fb_customSnapshot]];
   return [scrollViewWrapped fb_scrollByVector:scrollVector
-                                inApplication:self.application
+                                anchorElement:scrollViewElement
                                         error:error];
 }
 
@@ -250,42 +301,42 @@ const CGFloat FBScrollTouchProportion = 0.75f;
   return self.visibleFrame;
 }
 
-- (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance
-                          inApplication:(XCUIApplication *)application
+- (BOOL)fb_scrollUpByNormalizedDistance:(CGFloat)distance
+                           anchorElement:(XCUIElement *)anchorElement
 {
-  [self fb_scrollByNormalizedVector:CGVectorMake(0.0, distance) inApplication:application];
+  return [self fb_scrollByNormalizedVector:CGVectorMake(0.0, distance) anchorElement:anchorElement];
 }
 
-- (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance
-                            inApplication:(XCUIApplication *)application
+- (BOOL)fb_scrollDownByNormalizedDistance:(CGFloat)distance
+                             anchorElement:(XCUIElement *)anchorElement
 {
-  [self fb_scrollByNormalizedVector:CGVectorMake(0.0, -distance) inApplication:application];
+  return [self fb_scrollByNormalizedVector:CGVectorMake(0.0, -distance) anchorElement:anchorElement];
 }
 
-- (void)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
-                            inApplication:(XCUIApplication *)application
+- (BOOL)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
+                             anchorElement:(XCUIElement *)anchorElement
 {
-  [self fb_scrollByNormalizedVector:CGVectorMake(distance, 0.0) inApplication:application];
+  return [self fb_scrollByNormalizedVector:CGVectorMake(distance, 0.0) anchorElement:anchorElement];
 }
 
-- (void)fb_scrollRightByNormalizedDistance:(CGFloat)distance
-                             inApplication:(XCUIApplication *)application
+- (BOOL)fb_scrollRightByNormalizedDistance:(CGFloat)distance
+                              anchorElement:(XCUIElement *)anchorElement
 {
-  [self fb_scrollByNormalizedVector:CGVectorMake(-distance, 0.0) inApplication:application];
+  return [self fb_scrollByNormalizedVector:CGVectorMake(-distance, 0.0) anchorElement:anchorElement];
 }
 
 - (BOOL)fb_scrollByNormalizedVector:(CGVector)normalizedScrollVector
-                      inApplication:(XCUIApplication *)application
+                       anchorElement:(XCUIElement *)anchorElement
 {
   CGVector scrollVector = CGVectorMake(CGRectGetWidth(self.scrollingFrame) * normalizedScrollVector.dx,
                                        CGRectGetHeight(self.scrollingFrame) * normalizedScrollVector.dy
                                        );
-  return [self fb_scrollByVector:scrollVector inApplication:application error:nil];
+  return [self fb_scrollByVector:scrollVector anchorElement:anchorElement error:nil];
 }
 
 - (BOOL)fb_scrollByVector:(CGVector)vector
-            inApplication:(XCUIApplication *)application
-                    error:(NSError **)error
+             anchorElement:(XCUIElement *)anchorElement
+                     error:(NSError **)error
 {
   CGVector scrollBoundingVector = CGVectorMake(
                                                CGRectGetWidth(self.scrollingFrame) * FBScrollTouchProportion,
@@ -302,29 +353,41 @@ const CGFloat FBScrollTouchProportion = 0.75f;
                                          fabs(vector.dy) > fabs(scrollBoundingVector.dy) ? scrollBoundingVector.dy : vector.dy);
     vector = CGVectorMake(vector.dx - scrollVector.dx, vector.dy - scrollVector.dy);
     shouldFinishScrolling = FBVectorFuzzyEqualToVector(vector, CGZeroVector, 1) || --preciseScrollAttemptsCount <= 0;
-    if (![self fb_scrollAncestorScrollViewByVectorWithinScrollViewFrame:scrollVector inApplication:application error:error]){
+    if (![self fb_scrollAncestorScrollViewByVectorWithinScrollViewFrame:scrollVector anchorElement:anchorElement error:error]){
       return NO;
     }
   }
   return YES;
 }
 
-- (CGVector)fb_hitPointOffsetForScrollingVector:(CGVector)scrollingVector
+// Normalized (0.0-1.0) touch-down offset within the scrolling frame, for the given
+// scroll vector's direction.
+- (CGVector)fb_normalizedHitPointOffsetForScrollingVector:(CGVector)scrollingVector
 {
-  CGFloat x = CGRectGetMinX(self.scrollingFrame) + CGRectGetWidth(self.scrollingFrame) * (scrollingVector.dx < 0.0f ? FBScrollTouchProportion : (1 - FBScrollTouchProportion));
-  CGFloat y = CGRectGetMinY(self.scrollingFrame) + CGRectGetHeight(self.scrollingFrame) * (scrollingVector.dy < 0.0f ? FBScrollTouchProportion : (1 - FBScrollTouchProportion));
-  return CGVectorMake((CGFloat)floor(x), (CGFloat)floor(y));
+  CGFloat x = scrollingVector.dx < 0.0f ? FBScrollTouchProportion : (1 - FBScrollTouchProportion);
+  CGFloat y = scrollingVector.dy < 0.0f ? FBScrollTouchProportion : (1 - FBScrollTouchProportion);
+  return CGVectorMake(x, y);
 }
 
 - (BOOL)fb_scrollAncestorScrollViewByVectorWithinScrollViewFrame:(CGVector)vector
-                                                   inApplication:(XCUIApplication *)application
-                                                           error:(NSError **)error
+                                                     anchorElement:(XCUIElement *)anchorElement
+                                                             error:(NSError **)error
 {
-  CGVector hitpointOffset = [self fb_hitPointOffsetForScrollingVector:vector];
+  CGRect scrollingFrame = self.scrollingFrame;
+  // wdFrame matches scrollingFrame's coordinate space; raw .frame can be pre-scaled or
+  // dimension-swapped and drift out of sync with it (appium/appium#16185).
+  CGRect anchorFrame = anchorElement.wdFrame;
+  if (CGRectIsEmpty(scrollingFrame) || CGRectIsEmpty(anchorFrame)) {
+    return [[[FBErrorBuilder builder]
+             withDescriptionFormat:@"Cannot compute a scroll gesture for '%@': its frame is empty", self.fb_description]
+            buildError:error];
+  }
 
-  XCUICoordinate *appCoordinate = [[XCUICoordinate alloc] initWithElement:application normalizedOffset:CGVectorMake(0.0, 0.0)];
-  XCUICoordinate *startCoordinate = [[XCUICoordinate alloc] initWithCoordinate:appCoordinate pointsOffset:hitpointOffset];
-  XCUICoordinate *endCoordinate = [[XCUICoordinate alloc] initWithCoordinate:startCoordinate pointsOffset:vector];
+  CGVector proportion = [self fb_normalizedHitPointOffsetForScrollingVector:vector];
+  CGVector startOffset, endOffset;
+  FBScrollGestureOffsets(scrollingFrame, anchorFrame, proportion, vector, &startOffset, &endOffset);
+  XCUICoordinate *startCoordinate = [anchorElement coordinateWithNormalizedOffset:startOffset];
+  XCUICoordinate *endCoordinate = [anchorElement coordinateWithNormalizedOffset:endOffset];
 
   if (FBPointFuzzyEqualToPoint(startCoordinate.screenPoint, endCoordinate.screenPoint, FBFuzzyPointThreshold)) {
     return YES;

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBTVFocuse.m

@@ -24,7 +24,7 @@ int const MAX_ITERATIONS_COUNT = 100;
 
 - (BOOL)fb_setFocusWithError:(NSError**) error
 {
-  [XCUIApplication.fb_activeApplication fb_waitUntilStableWithTimeout:FBConfiguration.animationCoolOffTimeout];
+  [XCUIApplication.fb_activeApplication fb_waitUntilStableWithTimeout:FBConfiguration.sharedInstance.animationCoolOffTimeout];
 
   if (!self.wdEnabled) {
     if (error) {
@@ -36,12 +36,13 @@ int const MAX_ITERATIONS_COUNT = 100;
 
   FBTVNavigationTracker *tracker = [FBTVNavigationTracker trackerWithTargetElement:self];
   for (int i = 0; i < MAX_ITERATIONS_COUNT; i++) {
-    // Here hasFocus works so far. Maybe, it is because it is handled by `XCUIRemote`...
-    if (self.hasFocus) {
+    FBTVDirection direction = FBTVDirectionNone;
+    FBTVFocusState focusState = [tracker pollFocusState:&direction];
+    if (focusState == FBTVFocusStateFocused) {
       return YES;
     }
 
-    if (!self.exists) {
+    if (focusState == FBTVFocusStateGone) {
       if (error) {
         *error = [[FBErrorBuilder.builder withDescription:
                    [NSString stringWithFormat:@"'%@' element is not reachable because it does not exist. Try to use XCUIRemote commands.", self.description]] build];
@@ -49,7 +50,6 @@ int const MAX_ITERATIONS_COUNT = 100;
       return NO;
     }
 
-    FBTVDirection direction = tracker.directionToFocusedElement;
     if (direction != FBTVDirectionNone) {
       [[XCUIRemote sharedRemote] pressButton: (XCUIRemoteButton)direction];
     }

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBTyping.h

@@ -7,6 +7,7 @@
  */
 
 #import <XCTest/XCTest.h>
+#import <WebDriverAgentLib/FBXCElementSnapshot.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -50,6 +51,25 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error);
           frequency:(NSUInteger)frequency
               error:(NSError **)error;
 
+/**
+ Types a text into element, reusing a snapshot the caller already holds
+ instead of fetching a new one. Only pass a snapshot that is known to
+ reflect the element's current state (e.g. one taken moments earlier in
+ the same operation) - a stale snapshot here will not be detected as such.
+
+ @param text text that should be typed
+ @param shouldClear Whether to clear the input field before start typing
+ @param frequency Frequency of typing (letters per sec)
+ @param snapshot A recent snapshot of the receiver
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if the operation succeeds, otherwise NO.
+ */
+- (BOOL)fb_typeText:(NSString *)text
+        shouldClear:(BOOL)shouldClear
+          frequency:(NSUInteger)frequency
+           snapshot:(id<FBXCElementSnapshot>)snapshot
+              error:(NSError **)error;
+
 /**
  Clears text on element.
  It will try to activate keyboard on element, if element has no keyboard focus.
@@ -59,6 +79,19 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error);
  */
 - (BOOL)fb_clearTextWithError:(NSError **)error;
 
+/**
+ Clears text on element, reusing a snapshot the caller already holds
+ instead of fetching a new one. Only pass a snapshot that is known to
+ reflect the element's current state (e.g. one taken moments earlier in
+ the same operation) - a stale snapshot here will not be detected as such.
+
+ @param snapshot A recent snapshot of the receiver
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if the operation succeeds, otherwise NO.
+ */
+- (BOOL)fb_clearTextWithSnapshot:(id<FBXCElementSnapshot>)snapshot
+                            error:(NSError **)error;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBTyping.m

@@ -89,6 +89,10 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error)
 #if !TARGET_OS_TV
   [FBLogger logFmt:@"Trying to tap the \"%@\" element to have it focused", snapshot.fb_description];
   [self tap];
+#if TARGET_OS_WATCH
+  // watchOS presents a full-screen keyboard sheet (a modal transition) - wait for it.
+  [self fb_waitUntilStableWithTimeout:2.0];
+#endif
   // It might take some time to update the UI
   [self fb_standardSnapshot];
 #endif
@@ -100,7 +104,7 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error)
 {
   return [self fb_typeText:text
                shouldClear:shouldClear
-                 frequency:FBConfiguration.maxTypingFrequency
+                 frequency:FBConfiguration.sharedInstance.maxTypingFrequency
                      error:error];
 }
 
@@ -109,18 +113,48 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error)
           frequency:(NSUInteger)frequency
               error:(NSError **)error
 {
+  // No snapshot was handed to us, so there is nothing to safely reuse -
+  // always fetch a fresh one.
   id<FBXCElementSnapshot> snapshot = [self fb_standardSnapshot];
+  return [self fb_typeText:text
+               shouldClear:shouldClear
+                 frequency:frequency
+                  snapshot:snapshot
+                     error:error];
+}
+
+- (BOOL)fb_typeText:(NSString *)text
+        shouldClear:(BOOL)shouldClear
+          frequency:(NSUInteger)frequency
+           snapshot:(id<FBXCElementSnapshot>)snapshot
+              error:(NSError **)error
+{
   FBXCElementSnapshotWrapper *wrapped = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
   [self fb_prepareForTextInputWithSnapshot:wrapped];
   if (shouldClear && ![self fb_clearTextWithSnapshot:wrapped shouldPrepareForInput:NO error:error]) {
     return NO;
   }
+#if TARGET_OS_WATCH
+  // FBTypeText's low-level key synthesis never reaches watchOS's keyboard; -typeText: is a
+  // partial workaround (keystrokes still don't always land - a known limitation).
+  [self typeText:text];
+  return YES;
+#else
   return FBTypeText(text, frequency, error);
+#endif
 }
 
 - (BOOL)fb_clearTextWithError:(NSError **)error
 {
+  // No snapshot was handed to us, so there is nothing to safely reuse -
+  // always fetch a fresh one.
   id<FBXCElementSnapshot> snapshot = [self fb_standardSnapshot];
+  return [self fb_clearTextWithSnapshot:snapshot error:error];
+}
+
+- (BOOL)fb_clearTextWithSnapshot:(id<FBXCElementSnapshot>)snapshot
+                            error:(NSError **)error
+{
   return [self fb_clearTextWithSnapshot:[FBXCElementSnapshotWrapper ensureWrapped:snapshot]
                   shouldPrepareForInput:YES
                                   error:error];
@@ -161,7 +195,7 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error)
       [self fb_prepareForTextInputWithSnapshot:snapshot];
     }
 
-    if (retry == 0 && FBConfiguration.useClearTextShortcut) {
+    if (retry == 0 && FBConfiguration.sharedInstance.useClearTextShortcut) {
       // 1st attempt is via the IOHIDEvent as the fastest operation
       // https://github.com/appium/appium/issues/19389
       [[XCUIDevice sharedDevice] fb_performIOHIDEventWithPage:0x07  // kHIDPage_KeyboardOrKeypad
@@ -171,8 +205,8 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error)
     } else if (retry >= MAX_CLEAR_RETRIES - 1) {
       // Last chance retry. Tripple-tap the field to select its content
       [self tapWithNumberOfTaps:3 numberOfTouches:1];
-      return FBTypeText(backspaceDeleteSequence, FBConfiguration.defaultTypingFrequency, error);
-    } else if (!FBTypeText(backspacesToType, FBConfiguration.defaultTypingFrequency, error)) {
+      return FBTypeText(backspaceDeleteSequence, FBConfiguration.sharedInstance.defaultTypingFrequency, error);
+    } else if (!FBTypeText(backspacesToType, FBConfiguration.sharedInstance.defaultTypingFrequency, error)) {
       // 2nd operation
       return NO;
     }
@@ -192,7 +226,7 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error)
   // kHIDPage_KeyboardOrKeypad did not work for tvOS's search field. (tvOS 17 at least)
   // Tested XCUIElementTypeSearchField and XCUIElementTypeTextView whch were
   // common search field and email/passowrd input in tvOS apps.
-  return FBTypeText(backspacesToType, FBConfiguration.defaultTypingFrequency, error);
+  return FBTypeText(backspacesToType, FBConfiguration.sharedInstance.defaultTypingFrequency, error);
 #endif
 }
 

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBUtilities.m

@@ -100,9 +100,11 @@
     }
   }
   NSMutableArray<XCUIElement *> *matchedElements = [NSMutableArray array];
-  NSString *uid = nil == self.lastSnapshot
+  // self.lastSnapshot may be stale leftover from an unrelated earlier command.
+  id<FBXCElementSnapshot> selfSnapshot = self.fb_cachedSnapshot;
+  NSString *uid = nil == selfSnapshot
     ? self.fb_uid
-    : [FBXCElementSnapshotWrapper wdUIDWithSnapshot:self.lastSnapshot];
+    : [FBXCElementSnapshotWrapper wdUIDWithSnapshot:selfSnapshot];
   if (nil != uid && [matchedIds containsObject:uid]) {
     XCUIElement *stableSelf = [self fb_stableInstanceWithUid:uid];
     if (1 == snapshots.count) {
@@ -113,7 +115,7 @@
   XCUIElementType type = XCUIElementTypeAny;
   NSArray<NSNumber *> *uniqueTypes = [snapshots valueForKeyPath:[NSString stringWithFormat:@"@distinctUnionOfObjects.%@", FBStringify(XCUIElement, elementType)]];
   if (uniqueTypes && [uniqueTypes count] == 1) {
-    type = [uniqueTypes.firstObject intValue];
+    type = (XCUIElementType)[uniqueTypes.firstObject intValue];
   }
   XCUIElementQuery *query = onlyChildren
     ? [self.fb_query childrenMatchingType:type]
@@ -130,7 +132,7 @@
 
 - (void)fb_waitUntilStable
 {
-  [self fb_waitUntilStableWithTimeout:FBConfiguration.waitForIdleTimeout];
+  [self fb_waitUntilStableWithTimeout:FBConfiguration.sharedInstance.waitForIdleTimeout];
 }
 
 - (void)fb_waitUntilStableWithTimeout:(NSTimeInterval)timeout
@@ -139,9 +141,9 @@
     return;
   }
 
-  NSTimeInterval previousTimeout = FBConfiguration.waitForIdleTimeout;
+  NSTimeInterval previousTimeout = FBConfiguration.sharedInstance.waitForIdleTimeout;
   BOOL previousQuiescence = self.application.fb_shouldWaitForQuiescence;
-  FBConfiguration.waitForIdleTimeout = timeout;
+  FBConfiguration.sharedInstance.waitForIdleTimeout = timeout;
   if (!previousQuiescence) {
     self.application.fb_shouldWaitForQuiescence = YES;
   }
@@ -150,7 +152,7 @@
   if (previousQuiescence != self.application.fb_shouldWaitForQuiescence) {
     self.application.fb_shouldWaitForQuiescence = previousQuiescence;
   }
-  FBConfiguration.waitForIdleTimeout = previousTimeout;
+  FBConfiguration.sharedInstance.waitForIdleTimeout = previousTimeout;
 }
 
 - (void)fb_raiseStaleElementExceptionWithError:(NSError *)error __attribute__((noreturn))

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBVisibleFrame.m

@@ -29,13 +29,19 @@
 {
   CGRect thisVisibleFrame = [self visibleFrame];
   if (!CGRectIsEmpty(thisVisibleFrame)) {
-    return thisVisibleFrame;
+    return CGRectMake(CGRectGetMinX(thisVisibleFrame),
+                      CGRectGetMinY(thisVisibleFrame),
+                      CGRectGetWidth(thisVisibleFrame),
+                      CGRectGetHeight(thisVisibleFrame));
   }
 
   NSDictionary *visibleFrameDict = [self fb_attributeValue:FB_XCAXAVisibleFrameAttributeName
                                                      error:nil];
   if (nil == visibleFrameDict) {
-    return thisVisibleFrame;
+    return CGRectMake(CGRectGetMinX(thisVisibleFrame),
+                      CGRectGetMinY(thisVisibleFrame),
+                      CGRectGetWidth(thisVisibleFrame),
+                      CGRectGetHeight(thisVisibleFrame));
   }
 
   id x = [visibleFrameDict objectForKey:@"X"];
@@ -46,7 +52,10 @@
     return CGRectMake([x doubleValue], [y doubleValue], [width doubleValue], [height doubleValue]);
   }
 
-  return thisVisibleFrame;
+  return CGRectMake(CGRectGetMinX(thisVisibleFrame),
+                    CGRectGetMinY(thisVisibleFrame),
+                    CGRectGetWidth(thisVisibleFrame),
+                    CGRectGetHeight(thisVisibleFrame));
 }
 
 @end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBWebDriverAttributes.m

@@ -37,7 +37,7 @@
     return [self fb_nativeSnapshot];
   }
   // https://github.com/appium/WebDriverAgent/issues/1085
-  if (FBConfiguration.enforceCustomSnapshots) {
+  if (FBConfiguration.sharedInstance.enforceCustomSnapshots) {
     return [self fb_customSnapshot];
   }
   // https://github.com/appium/appium-xcuitest-driver/issues/2552
@@ -202,6 +202,11 @@
   return self.hasFocus;
 }
 
+- (BOOL)isWDNativeAccessibilityElement
+{
+  return self.fb_isAccessibilityElement;
+}
+
 - (BOOL)isWDAccessible
 {
   XCUIElementType elementType = self.elementType;

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElementQuery+FBHelpers.m

@@ -11,6 +11,7 @@
 #import "FBXCodeCompatibility.h"
 #import "XCUIElementQuery.h"
 #import "FBXCElementSnapshot.h"
+#import "XCTElementSetTransformer-Protocol.h"
 
 @implementation XCUIElementQuery (FBHelpers)