Fix sibling switch redirection for value queries and extract duplicated polling logic

- Only apply sibling switch redirection for label-based queries, not value or id queries
- Extract polling retry logic into shared AccessibilityPoller.pollForResolution function
- Fixes test assertion failure in elementsWithSameTypeAndFrameButDifferentRolesAreDistinct
- Eliminates code duplication between batch and direct tap polling paths

Author: cursoragent

Sources/AXe/Utilities/AccessibilityPoller.swift

@@ -10,7 +10,26 @@ struct AccessibilityPoller {
         elementType: String? = nil,
         logger: AxeLogger
     ) async throws -> TapResolution {
-        let roots = try await AccessibilityFetcher.fetchAccessibilityElements(for: simulatorUDID, logger: logger)
+        try await pollForResolution(
+            query: query,
+            waitTimeout: waitTimeout,
+            pollInterval: pollInterval,
+            elementType: elementType,
+            logger: logger
+        ) {
+            try await AccessibilityFetcher.fetchAccessibilityElements(for: simulatorUDID, logger: logger)
+        }
+    }
+
+    static func pollForResolution(
+        query: AccessibilityQuery,
+        waitTimeout: TimeInterval,
+        pollInterval: TimeInterval,
+        elementType: String?,
+        logger: AxeLogger,
+        rootsFetcher: () async throws -> [AccessibilityElement]
+    ) async throws -> TapResolution {
+        let roots = try await rootsFetcher()
         do {
             return try AccessibilityTargetResolver.resolveTap(roots: roots, query: query, elementType: elementType)
         } catch let error as ElementResolutionError where error.isNotFound && waitTimeout > 0 {
@@ -22,7 +41,7 @@ struct AccessibilityPoller {
                 logger.info().log("Element not found, retrying in \(pollInterval)s…")
                 try await Task.sleep(for: .seconds(pollInterval))
 
-                let freshRoots = try await AccessibilityFetcher.fetchAccessibilityElements(for: simulatorUDID, logger: logger)
+                let freshRoots = try await rootsFetcher()
                 do {
                     return try AccessibilityTargetResolver.resolveTap(roots: freshRoots, query: query, elementType: elementType)
                 } catch let retryError as ElementResolutionError where retryError.isNotFound {

Sources/AXe/Utilities/AccessibilityTargetResolver.swift

@@ -4,6 +4,15 @@ enum AccessibilityQuery {
     case id(String)
     case label(String)
     case value(String)
+
+    var allowsSiblingRedirection: Bool {
+        switch self {
+        case .label:
+            return true
+        case .id, .value:
+            return false
+        }
+    }
 }
 
 enum ElementResolutionError: LocalizedError {
@@ -81,7 +90,8 @@ struct AccessibilityTargetResolver {
         let activationElement = try selectActivationElement(
             from: matchedElement,
             roots: roots,
-            selectorDescription: selectorDescription
+            selectorDescription: selectorDescription,
+            allowSiblingRedirection: query.allowsSiblingRedirection
         )
 
         guard let frame = activationElement.frame else {
@@ -157,7 +167,8 @@ struct AccessibilityTargetResolver {
     private static func selectActivationElement(
         from matchedElement: AccessibilityElement,
         roots: [AccessibilityElement],
-        selectorDescription: String
+        selectorDescription: String,
+        allowSiblingRedirection: Bool
     ) throws -> AccessibilityElement {
         if matchedElement.isSwitchLikeControl {
             return matchedElement
@@ -178,7 +189,7 @@ struct AccessibilityTargetResolver {
             return matchedElement
         }
 
-        if let ancestor = nearestAncestor(of: matchedElement, in: roots) {
+        if allowSiblingRedirection, let ancestor = nearestAncestor(of: matchedElement, in: roots) {
             let siblingSwitches = ancestor.switchLikeDescendantsIncludingSelf()
             if siblingSwitches.count == 1 {
                 return siblingSwitches[0]

Sources/AXe/Utilities/Batch/Command+BatchConvertible.swift

@@ -29,28 +29,17 @@ private func resolveBatchTapPoint(
     elementType: String?,
     logger: AxeLogger
 ) async throws -> TapResolution {
-    let roots = try await context.accessibilityRoots(logger: logger)
-    do {
-        return try AccessibilityTargetResolver.resolveTap(roots: roots, query: query, elementType: elementType)
-    } catch let error as ElementResolutionError where error.isNotFound && context.waitTimeout > 0 {
-        let clock = ContinuousClock()
-        let deadline = clock.now + .seconds(context.waitTimeout)
-
-        var lastError = error
-        while clock.now < deadline {
-            logger.info().log("Element not found, retrying in \(context.pollInterval)s…")
-            try await Task.sleep(for: .seconds(context.pollInterval))
-
-            let freshRoots = try await context.accessibilityRoots(logger: logger, forceRefresh: true)
-            do {
-                return try AccessibilityTargetResolver.resolveTap(roots: freshRoots, query: query, elementType: elementType)
-            } catch let retryError as ElementResolutionError where retryError.isNotFound {
-                lastError = retryError
-                continue
-            }
-        }
-
-        throw lastError
+    var isFirstFetch = true
+    return try await AccessibilityPoller.pollForResolution(
+        query: query,
+        waitTimeout: context.waitTimeout,
+        pollInterval: context.pollInterval,
+        elementType: elementType,
+        logger: logger
+    ) {
+        let forceRefresh = !isFirstFetch
+        isFirstFetch = false
+        return try await context.accessibilityRoots(logger: logger, forceRefresh: forceRefresh)
     }
 }