agent-device 0.21.0 → 0.21.1

package/android/ime-helper/dist/agent-device-android-ime-helper-0.21.1.apk.sha256

@@ -0,0 +1 @@
+65454a4663596adfc7fccd9a30e42f02b5ecde17eb1514fa115ef3036171b995  agent-device-android-ime-helper-0.21.1.apk

package/android/ime-helper/dist/{agent-device-android-ime-helper-0.21.0.manifest.json → agent-device-android-ime-helper-0.21.1.manifest.json}

@@ -1,10 +1,10 @@
 {
   "name": "android-ime-helper",
-  "version": "0.21.0",
-  "assetName": "agent-device-android-ime-helper-0.21.0.apk",
-  "sha256": "2f486edc5788d34f3ba8afd551f33e59a4823a6f358d2a3e883e93b3f2a0d7e8",
+  "version": "0.21.1",
+  "assetName": "agent-device-android-ime-helper-0.21.1.apk",
+  "sha256": "65454a4663596adfc7fccd9a30e42f02b5ecde17eb1514fa115ef3036171b995",
   "packageName": "com.callstack.agentdevice.imehelper",
-  "versionCode": 21000,
+  "versionCode": 21001,
   "serviceComponent": "com.callstack.agentdevice.imehelper/.TestInputMethodService",
   "broadcastProtocol": "android-ime-helper-v1"
 }

package/android/snapshot-helper/dist/agent-device-android-snapshot-helper-0.21.1.apk.sha256

@@ -0,0 +1 @@
+6ee75909ac499eca439d3663717d8fc1928ada3fec71bf2ae85fb567967a3793  agent-device-android-snapshot-helper-0.21.1.apk

package/android/snapshot-helper/dist/{agent-device-android-snapshot-helper-0.21.0.manifest.json → agent-device-android-snapshot-helper-0.21.1.manifest.json}

@@ -1,13 +1,13 @@
 {
   "name": "android-snapshot-helper",
-  "version": "0.21.0",
-  "releaseTag": "v0.21.0",
-  "assetName": "agent-device-android-snapshot-helper-0.21.0.apk",
+  "version": "0.21.1",
+  "releaseTag": "v0.21.1",
+  "assetName": "agent-device-android-snapshot-helper-0.21.1.apk",
   "apkUrl": null,
-  "sha256": "536b4096b0bfd7e224a6ebbeeff1daaca0a8df4dc56abd3e410541ad1733048f",
-  "checksumName": "agent-device-android-snapshot-helper-0.21.0.apk.sha256",
+  "sha256": "6ee75909ac499eca439d3663717d8fc1928ada3fec71bf2ae85fb567967a3793",
+  "checksumName": "agent-device-android-snapshot-helper-0.21.1.apk.sha256",
   "packageName": "com.callstack.agentdevice.snapshothelper",
-  "versionCode": 21000,
+  "versionCode": 21001,
   "instrumentationRunner": "com.callstack.agentdevice.snapshothelper/.SnapshotInstrumentation",
   "minSdk": 23,
   "targetSdk": 36,

package/apple/snapshot-bridge/README.md

@@ -8,7 +8,7 @@ and is never downloaded, pre-signed, or built by npm installation.
 
 The guest process uses the `XCTAccessibilityFramework` remote-access client
 from the simulator runtime and the `userTestingSnapshotForElement:options:error:`
-single-fetch API. Requests and responses are length-prefixed JSON frames:
+snapshot API. Requests and responses are length-prefixed JSON frames:
 
 ```text
 uint32 big-endian byte length
@@ -47,3 +47,60 @@ app tree. The existing route then uses XCTest, which owns system-modal
 resolution. Secondary owners such as the return-to-app status-bar control do
 not replace the native primary owner. The route's generation circuit remains
 disabled after fallback until that app relaunches.
+
+## Remote content
+
+The reader snapshots one process. A WebKit page — Safari's or a `WKWebView`'s —
+lives in a WebContent process and appears in that tree as an `AXRemoteElement`
+leaf under the web view. The guest returns the leaf as delivered; the host
+refuses a tree in which such a leaf sits under a web view and reaches the
+viewport, or reports no frame (`remote-content-boundary`), and routes that app
+generation to XCTest, which resolves remote elements (#2484). A zero-area or
+off-screen leaf is published: it hosts nothing the capture can miss.
+
+## Bounded depth recovery
+
+A healthy capture uses one native request. If native acquisition rejects it,
+`SnapshotBridgeCapture.m` retries supported native failure codes at lower depths
+and fetches withheld children from their accessibility elements. The completed
+tree keeps the original depth and node limits; partial trees disclose truncation.
+The traversal depth counts edges below the root; native requests count the root
+as one level. Each acquisition allows two lower-depth retries, and recovery
+allows at most 32 native requests within the existing capture deadline,
+checks foreground ownership on every request, and returns a failure when it
+cannot complete a continuation. Budget exhaustion and malformed continuations
+use non-launch failure codes, so the route falls back without launch re-polling.
+At each native fragment boundary, an absent or invalid child count means unknown
+completeness and fails closed. Natural leaves above that boundary need no
+continuation evidence. Unchanged native dictionaries and child arrays are reused.
+
+## Accepted-depth hints
+
+The host source (`packages/platform-apple/src/snapshot-source/depth-hints.ts`)
+remembers the native levels a finished recovery accepted, keyed by the resolved
+target id, its app generation, and this producer. The next capture of that
+generation sends `nativeLevelsHint`, so the guest's first request asks for the
+accepted levels instead of re-paying the known rejection. A hint changes the
+request strategy only: the delivered depth, node bounds, and completeness rules
+are unchanged. Hints are learned only from a recovery that observed a rejection
+and then finished (a tree bounded by the requested depth or node budget still
+teaches), never cross apps, generations, or producers, and expire after eight
+hinted captures so the next capture probes the full depth again; a capture that
+merely succeeds at the hinted depth does not renew it. Explicit raw-depth
+requests neither use nor teach hints. Every response carries `recovery`
+(`requests`, `rejected`, `continuations`, `acceptedLevels`), which the host
+emits as the `ios_snapshot_source_recovery` diagnostic.
+
+## Recovery conformance
+
+`contracts/fixtures/ios-ax-recovery-conformance.json` is the shared, executable
+recovery contract for this bridge and the XCTest runner's private AX bridge.
+`packages/platform-apple/src/snapshot-source/fixtures/recovery-conformance.m`
+replays each case through `captureSnapshotTree`; the runner replays the same
+cases through its own bridge in
+`RunnerTests+AXRecoveryConformanceTests.swift`. Each expectation names the
+outcome, the native request accounting, and the delivered tree as a canonical
+preorder signature with its retained node count, so a producer that drops,
+duplicates, reorders, or re-parents nodes cannot pass as complete. The fixture
+records each producer's expectation and documents the intentional differences
+(depth vocabulary, ladders, completeness evidence, budgets, hint lifetime).

package/apple/snapshot-bridge/SnapshotBridge.m

@@ -85,6 +85,11 @@ static NSDictionary *handleRequest(NSDictionary *request)
       !validBoundInteger(request[@"maxResponseBytes"], 1024, kMaximumFrameBytes, &maxResponseBytes)) {
     return failureResponse(requestId, @"bad_request", @"bounds-invalid", @"snapshot bridge request bounds are outside the bridge limits");
   }
+  NSUInteger nativeLevelsHint = 0;
+  if (request[@"nativeLevelsHint"] != nil &&
+      !validBoundInteger(request[@"nativeLevelsHint"], 1, kMaximumDepth + 1, &nativeLevelsHint)) {
+    return failureResponse(requestId, @"bad_request", @"bounds-invalid", @"nativeLevelsHint is outside the bridge depth limits");
+  }
 
   NSString *setupError = nil;
   BridgeRuntime *runtime = sharedRuntime(&setupError);
@@ -98,6 +103,7 @@ static NSDictionary *handleRequest(NSDictionary *request)
   NSDictionary *response = [runtime snapshotForProcess:pidValue.intValue
                                                maxDepth:maxDepth
                                                maxNodes:maxNodes
+                                       nativeLevelsHint:nativeLevelsHint
                                              requestId:requestId
                                            generation:generation
                                          maxDurationMs:maxDurationMs

package/apple/snapshot-bridge/SnapshotBridgeCapture.h

@@ -0,0 +1,25 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef id _Nullable (^SnapshotElementReader)(id element, NSUInteger depth, NSUInteger nodes, NSError **error);
+
+/// Native request accounting for one acquisition: requests issued, requests the accessibility
+/// server rejected at their depth, continuations (requests that reached the reader beyond the
+/// root's accepted one), and the native levels of the last accepted request.
+typedef struct {
+  NSUInteger requests;
+  NSUInteger rejected;
+  NSUInteger continuations;
+  NSUInteger acceptedLevels;
+} SnapshotCaptureRecovery;
+
+/// Materializes one bounded tree; retries bounded native acquisition failures and re-roots withheld
+/// children. `nativeLevelsHint` (0 for none) caps only the first request's native levels; the
+/// delivered depth, node bounds, and completeness rules are unchanged.
+NSDictionary *_Nullable captureSnapshotTree(id element, NSUInteger maxDepth, NSUInteger maxNodes,
+                                           NSUInteger nativeLevelsHint, SnapshotElementReader reader,
+                                           BOOL *truncated, SnapshotCaptureRecovery *_Nullable recovery,
+                                           NSError **error);
+
+NS_ASSUME_NONNULL_END

package/apple/snapshot-bridge/SnapshotBridgeCapture.m

@@ -0,0 +1,138 @@
+#import "SnapshotBridgeCapture.h"
+
+static NSString *const attributesKey = @"UIAccessibilitySnapshotKeyAttributes";
+static NSString *const childrenKey = @"UIAccessibilitySnapshotKeyChildren";
+static NSString *const childCountKey = @"UIAccessibilitySnapshotKeyChildrenCount";
+static NSString *const elementKey = @"UIAccessibilitySnapshotKeyElement";
+static const NSUInteger maximumRequests = 32;
+
+@interface SnapshotTreeCapture : NSObject
+@property(nonatomic, copy) SnapshotElementReader reader;
+@property(nonatomic) NSUInteger acceptedDepth;
+@property(nonatomic) NSUInteger remainingNodes;
+@property(nonatomic) NSUInteger maximumNodes;
+@property(nonatomic) NSUInteger requests;
+@property(nonatomic) NSUInteger rejected;
+@property(nonatomic) BOOL truncated;
+- (nullable NSDictionary *)read:(id)element depth:(NSUInteger)depth error:(NSError **)error;
+- (nullable NSDictionary *)materialize:(NSDictionary *)tree depth:(NSUInteger)depth nativeLevels:(NSUInteger)nativeLevels error:(NSError **)error;
+@end
+
+@implementation SnapshotTreeCapture
+- (nullable NSDictionary *)read:(id)element depth:(NSUInteger)depth error:(NSError **)error
+{
+  NSUInteger attemptDepth = MIN(depth, self.acceptedDepth);
+  for (NSUInteger retries = 0;; retries++) {
+    if (self.requests >= maximumRequests) {
+      if (error) *error = [NSError errorWithDomain:@"agent-device.snapshot" code:1
+          userInfo:@{NSLocalizedDescriptionKey: @"snapshot continuation request budget exhausted"}];
+      return nil;
+    }
+    self.requests++;
+    NSError *failure = nil;
+    id tree = self.reader(element, attemptDepth, MIN(self.maximumNodes, self.remainingNodes + 1), &failure);
+    if (tree) return tree;
+    NSNumber *nativeCode = failure.userInfo[@"accessibility-error"];
+    BOOL rejected = ([nativeCode isKindOfClass:NSNumber.class] && nativeCode.integerValue == -25201) ||
+        ([failure.domain isEqualToString:@"com.apple.dt.xctest.automation-support.error"] && failure.code == 5);
+    if (rejected) self.rejected++;
+    if (!rejected || attemptDepth <= 1 || retries >= 2) {
+      if (error) *error = failure;
+      return nil;
+    }
+    attemptDepth = MAX(1, attemptDepth / 2);
+    self.acceptedDepth = attemptDepth;
+  }
+}
+
+- (nullable NSDictionary *)materialize:(NSDictionary *)tree depth:(NSUInteger)depth nativeLevels:(NSUInteger)nativeLevels error:(NSError **)error
+{
+  if (![tree isKindOfClass:NSDictionary.class] ||
+      ![tree[attributesKey] isKindOfClass:NSDictionary.class] ||
+      ![tree[childrenKey] isKindOfClass:NSArray.class]) {
+    if (error) *error = [NSError errorWithDomain:@"agent-device.snapshot" code:2
+        userInfo:@{NSLocalizedDescriptionKey: @"malformed snapshot continuation"}];
+    return nil;
+  }
+  if (self.remainingNodes == 0) {
+    self.truncated = YES;
+    return nil;
+  }
+  self.remainingNodes--;
+  NSArray *children = tree[childrenKey];
+  NSNumber *childCount = tree[childCountKey];
+  BOOL knownChildCount = [childCount isKindOfClass:NSNumber.class] && childCount.doubleValue >= 0 &&
+      childCount.doubleValue == (double)childCount.unsignedIntegerValue;
+  if (nativeLevels <= 1 && !knownChildCount && depth <= 1) self.truncated = YES;
+  if (depth > 1 && nativeLevels <= 1 && !knownChildCount) {
+    if (error) *error = [NSError errorWithDomain:@"agent-device.snapshot" code:6
+        userInfo:@{NSLocalizedDescriptionKey: @"snapshot boundary child count unavailable"}];
+    return nil;
+  }
+  BOOL withheld = knownChildCount && childCount.unsignedIntegerValue > children.count;
+  if (depth <= 1 || self.remainingNodes == 0) {
+    self.truncated |= children.count > 0 || withheld;
+    if (children.count == 0) return tree;
+    NSMutableDictionary *bounded = [tree mutableCopy];
+    bounded[childrenKey] = @[];
+    return bounded;
+  }
+  if (withheld && children.count < self.remainingNodes) {
+    id element = tree[elementKey];
+    if (!element) {
+      if (error) *error = [NSError errorWithDomain:@"agent-device.snapshot" code:3
+          userInfo:@{NSLocalizedDescriptionKey: @"snapshot continuation element unavailable"}];
+      return nil;
+    }
+    NSDictionary *continuation = [self read:element depth:depth error:error];
+    if (!continuation) return nil;
+    nativeLevels = MIN(depth, self.acceptedDepth);
+    children = continuation[childrenKey];
+    if (![children isKindOfClass:NSArray.class] || children.count < MIN(childCount.unsignedIntegerValue, self.remainingNodes)) {
+      if (error) *error = [NSError errorWithDomain:@"agent-device.snapshot" code:4
+          userInfo:@{NSLocalizedDescriptionKey: @"snapshot continuation children unavailable"}];
+      return nil;
+    }
+  }
+  if (withheld && children.count < childCount.unsignedIntegerValue) self.truncated = YES;
+  NSMutableArray *materialized = nil;
+  NSUInteger index = 0;
+  for (NSDictionary *child in children) {
+    if (self.remainingNodes == 0) {
+      self.truncated = YES;
+      if (!materialized) materialized = [[children subarrayWithRange:NSMakeRange(0, index)] mutableCopy];
+      break;
+    }
+    NSDictionary *node = [self materialize:child depth:depth - 1 nativeLevels:(nativeLevels > 0 ? nativeLevels - 1 : 0) error:error];
+    if (!node) return nil;
+    if (node != child && !materialized) materialized = [[children subarrayWithRange:NSMakeRange(0, index)] mutableCopy];
+    [materialized addObject:node];
+    index++;
+  }
+  if (!materialized && children == tree[childrenKey]) return tree;
+  NSMutableDictionary *result = [tree mutableCopy];
+  result[childrenKey] = materialized ?: children;
+  return result;
+}
+@end
+
+NSDictionary *captureSnapshotTree(id element, NSUInteger maxDepth, NSUInteger maxNodes,
+                                  NSUInteger nativeLevelsHint, SnapshotElementReader reader,
+                                  BOOL *truncated, SnapshotCaptureRecovery *recovery, NSError **error)
+{
+  SnapshotTreeCapture *capture = [SnapshotTreeCapture new];
+  capture.reader = reader;
+  capture.acceptedDepth = nativeLevelsHint > 0 ? MIN(maxDepth + 1, nativeLevelsHint) : maxDepth + 1;
+  capture.remainingNodes = maxNodes;
+  capture.maximumNodes = maxNodes;
+  NSDictionary *tree = [capture read:element depth:maxDepth + 1 error:error];
+  NSDictionary *result = tree ? [capture materialize:tree depth:maxDepth + 1 nativeLevels:capture.acceptedDepth error:error] : nil;
+  *truncated = capture.truncated;
+  if (recovery) {
+    recovery->requests = capture.requests;
+    recovery->rejected = capture.rejected;
+    recovery->continuations = capture.requests - capture.rejected - (tree ? 1 : 0);
+    recovery->acceptedLevels = tree ? capture.acceptedDepth : 0;
+  }
+  return result;
+}

package/apple/snapshot-bridge/SnapshotBridgeRuntime.h

@@ -22,6 +22,7 @@ NSDictionary *failureResponse(NSString *requestId,
 - (nullable NSDictionary *)snapshotForProcess:(pid_t)pid
                                     maxDepth:(NSUInteger)maxDepth
                                     maxNodes:(NSUInteger)maxNodes
+                            nativeLevelsHint:(NSUInteger)nativeLevelsHint
                                   requestId:(NSString *)requestId
                                 generation:(NSString *)generation
                               maxDurationMs:(NSUInteger)maxDurationMs

package/apple/snapshot-bridge/SnapshotBridgeRuntime.m

@@ -5,6 +5,7 @@
  */
 
 #import "SnapshotBridgeRuntime.h"
+#import "SnapshotBridgeCapture.h"
 
 #import <CoreGraphics/CoreGraphics.h>
 #import <objc/message.h>
@@ -17,7 +18,7 @@
 NSString *const kProtocolVersionKey = @"protocolVersion";
 NSString *const kSourceVersionKey = @"sourceVersion";
 NSString *const kRequestIdKey = @"requestId";
-NSString *const kSourceVersion = @"agent-device-simulator-ax-v1.5.3";
+NSString *const kSourceVersion = @"agent-device-simulator-ax-v1.5.5";
 const NSUInteger kProtocolVersion = 1;
 const uint32_t kMaximumFrameBytes = 16 * 1024 * 1024;
 const NSUInteger kMaximumDepth = 128;
@@ -261,6 +262,7 @@ static void finishRequestWatchdog(dispatch_source_t watchdog, SnapshotWatchdogSt
 - (nullable NSDictionary *)snapshotForProcess:(pid_t)pid
                                     maxDepth:(NSUInteger)maxDepth
                                     maxNodes:(NSUInteger)maxNodes
+                            nativeLevelsHint:(NSUInteger)nativeLevelsHint
                                   requestId:(NSString *)requestId
                                 generation:(NSString *)generation
                               maxDurationMs:(NSUInteger)maxDurationMs
@@ -311,13 +313,27 @@ static void finishRequestWatchdog(dispatch_source_t watchdog, SnapshotWatchdogSt
   BOOL automationEnabled = [self assertAutomationMode:YES];
   NSError *runtimeError = nil;
   id snapshot = nil;
+  BOOL acquisitionTruncated = NO;
+  SnapshotCaptureRecovery recovery = {0, 0, 0, 0};
   @try {
     if (![self isPrimaryForegroundProcess:pid]) {
       if (error) *error = failureResponse(requestId, @"unsupported", @"foreground-owner-unverified", @"target app is not the primary foreground accessibility owner");
       finishRequestWatchdog(watchdog, watchdogState);
       return nil;
     }
-    snapshot = [_framework userTestingSnapshotForElement:(__bridge id)raw options:options error:&runtimeError];
+    snapshot = captureSnapshotTree((__bridge id)raw, maxDepth, maxNodes, nativeLevelsHint,
+        ^id(id element, NSUInteger depth, NSUInteger nodes, NSError **captureError) {
+          if (![self isPrimaryForegroundProcess:pid]) {
+            if (captureError) *captureError = [NSError errorWithDomain:@"agent-device.snapshot" code:5
+                userInfo:@{NSLocalizedDescriptionKey: @"foreground owner changed during continuation"}];
+            return nil;
+          }
+          NSMutableDictionary *bounded = [options mutableCopy];
+          bounded[@"maxDepth"] = @(depth);
+          bounded[@"maxChildren"] = @(nodes);
+          bounded[@"maxArrayCount"] = @(nodes);
+          return [_framework userTestingSnapshotForElement:element options:bounded error:captureError];
+        }, &acquisitionTruncated, &recovery, &runtimeError);
     if (![self isPrimaryForegroundProcess:pid]) {
       if (error) *error = failureResponse(requestId, @"unsupported", @"foreground-owner-changed", @"foreground accessibility ownership changed during acquisition");
       finishRequestWatchdog(watchdog, watchdogState);
@@ -328,6 +344,13 @@ static void finishRequestWatchdog(dispatch_source_t watchdog, SnapshotWatchdogSt
     finishRequestWatchdog(watchdog, watchdogState);
     return nil;
   }
+  if (!snapshot && [runtimeError.domain isEqualToString:@"agent-device.snapshot"]) {
+    BOOL exhausted = runtimeError.code == 1;
+    if (error) *error = failureResponse(requestId, exhausted ? @"reader_unavailable" : @"malformed_tree",
+        exhausted ? @"continuation-budget-exhausted" : @"snapshot-tree-malformed", runtimeError.localizedDescription);
+    finishRequestWatchdog(watchdog, watchdogState);
+    return nil;
+  }
   if (!snapshot) {
     NSNumber *axError = runtimeError.userInfo[kAccessibilityErrorKey];
     NSInteger code = [axError respondsToSelector:@selector(integerValue)] ? axError.integerValue : runtimeError.code;
@@ -362,8 +385,14 @@ static void finishRequestWatchdog(dispatch_source_t watchdog, SnapshotWatchdogSt
     @"ok" : @YES,
     @"pid" : @(pid),
     @"tree" : tree,
-    @"truncated" : @(truncated),
+    @"truncated" : @((BOOL)(truncated || acquisitionTruncated)),
     @"automationEnabled" : @(automationEnabled),
+    @"recovery" : @{
+      @"requests" : @(recovery.requests),
+      @"rejected" : @(recovery.rejected),
+      @"continuations" : @(recovery.continuations),
+      @"acceptedLevels" : @(recovery.acceptedLevels),
+    },
   };
 }
 @end

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.h

@@ -49,6 +49,18 @@ FOUNDATION_EXPORT NSString *const RunnerAXSnapshotCustomActionsBlockedKey;
                                            customActionLimit:(NSInteger)customActionLimit
                                                     deadline:(nullable NSDate *)deadline;
 
+/// The capture behind `snapshotTreeForApplication:`, for an AX client and target
+/// application element that are already resolved. Every request, extension, and
+/// custom-action decision happens here; the application entry point only resolves
+/// the two identities.
++ (NSDictionary<NSString *, id> *)snapshotTreeWithClient:(id)axClient
+                                                  target:(id)target
+                                                maxDepth:(NSInteger)maxDepth
+                                                maxNodes:(NSInteger)maxNodes
+                                  deepExtensionCallLimit:(NSInteger)deepExtensionCallLimit
+                                       customActionLimit:(NSInteger)customActionLimit
+                                                deadline:(nullable NSDate *)deadline;
+
 /// Names of the element's UIAccessibilityCustomActions, or nil when it has
 /// none.
 ///

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAXSnapshotBridge.m

@@ -104,7 +104,27 @@ typedef id (*RunnerAXSnapshotMsgSend)(id, SEL, id, id, id, NSError **);
     if (nil == target) {
       return [self failure:@"Could not match active AX application for XCTest application"];
     }
+    return [self snapshotTreeWithClient:axClient
+                                 target:target
+                               maxDepth:maxDepth
+                               maxNodes:maxNodes
+                 deepExtensionCallLimit:deepExtensionCallLimit
+                      customActionLimit:customActionLimit
+                               deadline:deadline];
+  } @catch (NSException *exception) {
+    return [self failure:exception.reason ?: exception.name ?: @"AX snapshot bridge exception"];
+  }
+}
 
++ (NSDictionary<NSString *, id> *)snapshotTreeWithClient:(id)axClient
+                                                  target:(id)target
+                                                maxDepth:(NSInteger)maxDepth
+                                                maxNodes:(NSInteger)maxNodes
+                                  deepExtensionCallLimit:(NSInteger)deepExtensionCallLimit
+                                       customActionLimit:(NSInteger)customActionLimit
+                                                deadline:(nullable NSDate *)deadline
+{
+  @try {
     NSArray *attributes = [self snapshotAttributes];
     NSError *error = nil;
     id root = [self requestSnapshotFromClient:axClient

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSelectorMatchPolicy.swift

@@ -20,26 +20,26 @@ enum DirectSelectorCandidateDecision: Equatable {
   case ambiguous
 }
 
-/// How many raw exact matches a dispatch may discard before hittability is
-/// allowed to pick a winner. The two rows differ because the cost of guessing
-/// wrong differs, not because the matching differs.
+
+
+
 enum DirectSelectorRawMatchPolicy: Equatable {
-  /// Mutations fail closed: every raw exact match counts, so a hittable
-  /// element can never silently win over a same-selector duplicate the caller
-  /// never saw and act on the wrong one.
+
+
+
   case rejectDistinctMatches
-  /// Reads prefer the single hittable match and ignore non-hittable
-  /// same-selector duplicates. A read has no side effect to guard, and
-  /// `querySelector` backs `get`/`is`/`wait` — failing those closed turns a
-  /// decorative duplicate into an error where the reader previously got its
-  /// answer.
+
+
+
+
+
   case preferHittableMatch
 }
 
-/// Normal direct selector mutations count every raw exact match before
-/// hittability can choose a winner. Reads keep the hittable-preference rule,
-/// and Maestro's explicitly requested coordinate fallback keeps its
-/// point-filtered compatibility behavior.
+
+
+
+
 func classifyDirectSelectorCandidates(
   _ candidates: [SelectorCandidateFacts],
   allowNonHittableFallback: Bool,

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSystemSurfaceHostPolicy.swift

@@ -0,0 +1,72 @@
+import Foundation
+
+
+
+
+
+enum SystemSurfaceHostKind: String {
+  case webAuth = "web-auth"
+}
+
+struct SystemSurfaceHost: Equatable {
+  let bundleId: String
+  let kind: SystemSurfaceHostKind
+}
+
+enum SystemSurfaceHostRegistry {
+  static let hosts: [SystemSurfaceHost] = [
+    SystemSurfaceHost(bundleId: "com.apple.SafariViewService", kind: .webAuth)
+  ]
+
+  static func host(forBundleId bundleId: String?) -> SystemSurfaceHost? {
+    guard let bundleId else { return nil }
+    return hosts.first { $0.bundleId == bundleId }
+  }
+
+  static func isSystemSurfaceHost(_ bundleId: String?) -> Bool {
+    host(forBundleId: bundleId) != nil
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTapPointPolicy.swift

@@ -1,19 +1,19 @@
 import XCTest
 
-// The tap-point rule the runner shares with the TS runtime (ADR 0011 Layer 2).
-//
-// RULE: the tap point is the element frame's CENTER; a tap is allowed iff that
-// center lies inside the window frame, edges inclusive. An empty or invalid
-// window frame fails open (allowed): resolving the best available frame is the
-// impure caller's job (onScreenWindowFrame / app.frame), and the policy must
-// not turn a missing frame into a refusal.
-//
-// This is pure geometry on purpose — no XCUIElement — so the exact decision
-// can be proven against the golden fixture table shared with the TS twin:
-//   table:   contracts/fixtures/tap-point-policy.json
-//   TS twin: packages/contracts/src/snapshot-visibility.ts#isTapPointInsideViewport
-//   TS test: packages/contracts/src/snapshot-tap-point-policy.test.ts
-// Drift on either side turns CI red without needing a simulator.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 enum TapPointPolicy {
   static func isAllowed(elementFrame: CGRect, windowFrame: CGRect) -> Bool {
     if windowFrame.isNull || windowFrame.isEmpty || windowFrame.isInfinite {
@@ -26,3 +26,52 @@ enum TapPointPolicy {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+