agent-device 0.21.0 → 0.21.1

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Snapshot.swift

@@ -48,9 +48,9 @@ extension RunnerTests {
     }
   }
 
-  // MARK: - Snapshot Entry
 
-  /// One raw-value table covers public XCTest cases and the SDK-hidden Keyboard/Key values.
+
+
   static let elementTypeNamesByRawValue = [
     XCUIElement.ElementType.application.rawValue: "Application",
     XCUIElement.ElementType.window.rawValue: "Window",
@@ -111,11 +111,11 @@ extension RunnerTests {
 
   static let flatInteractiveFallbackBudget: TimeInterval = 1.0
 
-  // The single production entry point -- always compiled, no unit-test overload. A unit test
-  // exercises this exact function; the only injectable seam lives inside
-  // `boundedBlockingSystemAlertSnapshot`'s probe closure (see `systemModalProbeOverrideForTesting`
-  // in RunnerTests.swift), so reverting this entry point to bypass the bounded probe fails the
-  // regression test.
+
+
+
+
+
   func snapshotFast(app: XCUIApplication, options: PresentationOptions) throws -> DataPayload {
     let deadline = Date().addingTimeInterval(Self.snapshotPlanBudget)
     if let blocking = boundedBlockingSystemAlertSnapshot(deadline: deadline) {
@@ -146,11 +146,11 @@ extension RunnerTests {
       return result.elements
     }
 
-    // Acquisition serializes facts: every traversed node is emitted at raw traversal depth, and
-    // the regular projection's clip fold runs once inside `SnapshotPresentation` (#1797). The two
-    // walks this backend keeps are the raw budget or regular presented-depth frontier, plus
-    // collapsed-tab augmentation which needs live element handles; neither walk publishes a
-    // presentation node.
+
+
+
+
+
     var nodes: [RawAXNode] = []
     let rootEvaluation = evaluateSnapshot(context.rootSnapshot)
     nodes.append(
@@ -269,7 +269,7 @@ extension RunnerTests {
     )
   }
 
-  // See `snapshotFast` above: the single production entry point, no unit-test overload.
+
   func snapshotRaw(app: XCUIApplication, options: PresentationOptions) throws -> DataPayload {
     let deadline = Date().addingTimeInterval(Self.snapshotPlanBudget)
     if let blocking = boundedBlockingSystemAlertSnapshot(deadline: deadline) {
@@ -284,19 +284,24 @@ extension RunnerTests {
     )
   }
 
-  /// Runs the pre-plan SpringBoard system-modal probe as a bounded capture tier sharing the plan
-  /// deadline, so a slow alert enumeration cannot bypass the snapshot timeout and stall (#1244).
+
+
   func boundedBlockingSystemAlertSnapshot(deadline: Date) -> DataPayload? {
     boundedBlockingSystemAlertSnapshotBody(deadline: deadline) { probeDeadline in
+
+
+
+
+
       return self.blockingSystemAlertSnapshot(deadline: probeDeadline)
     }
   }
 
-  /// The real bounding/hook machinery used by `boundedBlockingSystemAlertSnapshot` above: the
-  /// probe closure it's given always calls `self.blockingSystemAlertSnapshot` in production, and
-  /// in unit-test builds may first consult `systemModalProbeOverrideForTesting`. Keeping this in
-  /// one place means the `runMainThreadWork` wrap and the `onAbandoned`/`onDrained` hooks can
-  /// never drift between what production runs and what the unit tests exercise.
+
+
+
+
+
   private func boundedBlockingSystemAlertSnapshotBody(
     deadline: Date,
     probe: @escaping (Date) -> DataPayload?
@@ -350,8 +355,8 @@ extension RunnerTests {
     #endif
   }
 
-  /// The probe gets its own budget, clamped by whatever remains of the shared plan deadline, and
-  /// 0 (skip entirely) once that deadline is already spent.
+
+
   static func systemModalProbeSlice(
     budget: TimeInterval,
     deadlineRemaining: TimeInterval
@@ -419,8 +424,8 @@ extension RunnerTests {
       )
     }
 
-    // Bounded by both its own sweep budget and the umbrella capture-plan deadline, so a
-    // chained recovery tier can never push the plan past the main-thread watchdog (#1105).
+
+
     let sweepDeadline = hint.interactiveOnly
       ? Date().addingTimeInterval(Self.flatInteractiveFallbackBudget)
       : Date.distantFuture
@@ -459,9 +464,9 @@ extension RunnerTests {
       return left.type < right.type
     }
 
-    // The synthetic root doubles as the daemon's viewport (find.ts prefers on-screen matches
-    // inside nodes[0].rect): use the real screen viewport when capture produced a finite one,
-    // so off-screen candidates can never inflate the root and masquerade as on-screen.
+
+
+
     let rootRect = viewport.isInfinite || viewport.isNull || viewport.isEmpty
       ? interactiveRootFrame(for: candidates)
       : viewport
@@ -499,8 +504,8 @@ extension RunnerTests {
     NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_AX_UNAVAILABLE=%@", failure.message)
     runnerAccessibilityHealth = .unavailable
     invalidateCachedTarget(reason: Self.axSnapshotUnavailableReason)
-    // This is a planned terminal result, so it carries the structured verdict like every other
-    // planned snapshot — downstream sparse handling keys off the verdict, not node shapes.
+
+
     return sparseTruncatedSnapshotPayload(
       message: recoveredSnapshotMessage(failure),
       snapshotQuality: SnapshotQuality(
@@ -546,6 +551,248 @@ extension RunnerTests {
   }
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   private func interactiveRootNode(rect: CGRect) -> RawAXNode {
     RawAXNode(
       index: 0,
@@ -583,7 +830,7 @@ extension RunnerTests {
     )
   }
 
-  // MARK: - Snapshot Filtering
+
 
   func makeSnapshotTraversalContext(
     app: XCUIApplication,
@@ -619,8 +866,8 @@ extension RunnerTests {
     return abandonedTreeCaptureCount > 0
   }
 
-  /// The watchdog abandoned one unit of XCTest main-thread capture work that is still draining on
-  /// main; XCTest-backed snapshot tiers skip (`hasAbandonedTreeCapture`) until a matching release.
+
+
   func retainAbandonedXCTestChannelWork() {
     treeCaptureLock.lock()
     abandonedTreeCaptureCount += 1
@@ -633,11 +880,11 @@ extension RunnerTests {
     treeCaptureLock.unlock()
   }
 
-  /// Runs the blocking tree-snapshot XPC on the main thread bounded by `sliceSeconds`. On
-  /// timeout the XPC keeps running on main (it cannot be cancelled); the capture is marked
-  /// abandoned so plans avoid XCTest-backed tiers until it drains, the tree backend is penalized
-  /// for this bundle, and the plan moves to the platform's independent recovery tier when one
-  /// exists (#1105/#1122).
+
+
+
+
+
   private func captureSnapshotRootBounded(
     _ element: XCUIElement,
     sliceSeconds: TimeInterval
@@ -858,8 +1105,8 @@ extension RunnerTests {
     let containerFrame = containerSnapshot.frame
     if containerFrame.isNull || containerFrame.isEmpty { return [] }
 
-    // Collapsed tab containers should be rare, so a full descendant scan is acceptable once per
-    // snapshot as a fallback for XCTest omitting the tab children from the snapshot tree.
+
+
     let elements = resolveElements()
     let candidates = elements.compactMap { element in
       collapsedTabCandidateNode(
@@ -879,7 +1126,7 @@ extension RunnerTests {
     if candidates.count < 2 { return [] }
     let rowMidpoints = candidates.map { $0.rect.y + ($0.rect.height / 2) }
     let rowSpread = (rowMidpoints.max() ?? 0) - (rowMidpoints.min() ?? 0)
-    // Allow modest vertical jitter and short two-row wraps while still rejecting unrelated controls.
+
     if rowSpread > max(24.0, Double(containerFrame.height) * 0.6) { return [] }
 
     var seen = Set<String>()
@@ -1090,8 +1337,8 @@ extension RunnerTests {
     var node: RawAXNode?
     let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
       if !element.exists { return }
-      // Declared residue: a flat element query has no hierarchy for geometryless semantics to
-      // attach to, so frameless elements are dropped at acquisition rather than presented.
+
+
       let frame = element.frame
       if frame.isNull || frame.isEmpty { return }
       let label = element.label.trimmingCharacters(in: .whitespacesAndNewlines)

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+SnapshotBackendCapabilities.swift

@@ -5,14 +5,19 @@ enum SnapshotBackendEnvironment {
   case physicalDevice
 }
 
+
+
+
+
 enum SnapshotRegularDepthCapability: String {
-  /// The backend can stop acquisition at the requested regular presented-depth frontier.
+
   case presentedFrontier = "presented-frontier"
-  /// The backend is flat; it can answer the root and one presented level, but has no hierarchy
-  /// from which to prove deeper regular depth.
+
+
   case flat
-  /// The backend can return raw traversal depth, but cannot prove regular presented depth.
-  case rawOnly = "raw-only"
+
+
+  case presentationCut = "presentation-cut"
 }
 
 enum SnapshotBackendKind: String, CaseIterable {
@@ -42,10 +47,10 @@ enum SnapshotBackendKind: String, CaseIterable {
     }
   }
 
-  /// The raw projection is the acquired tree, so only a backend that enumerates a hierarchy can
-  /// serve it. The query sweep answers an interactive element query: it has no hierarchy to
-  /// return, and planning it for `--raw` is exactly how a raw request gets answered with regular
-  /// membership.
+
+
+
+
   var supportsRawProjection: Bool {
     switch self {
     case .recursiveTree, .privateAX:
@@ -62,19 +67,7 @@ enum SnapshotBackendKind: String, CaseIterable {
     case .querySweep:
       return .flat
     case .privateAX:
-      return .rawOnly
-    }
-  }
-
-  func canServeRegularPresentedDepth(_ requestedDepth: Int?) -> Bool {
-    guard let requestedDepth else { return true }
-    switch regularDepthCapability {
-    case .presentedFrontier:
-      return true
-    case .flat:
-      return requestedDepth <= 1
-    case .rawOnly:
-      return false
+      return .presentationCut
     }
   }
 
@@ -96,3 +89,80 @@ enum SnapshotBackendKind: String, CaseIterable {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+