agent-device 0.21.13 → 0.21.14

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

@@ -41,18 +41,13 @@ extension RunnerTests {
 
 
 
-    let geometry = try runMainThreadWork(
+    let viewport = try runMainThreadWork(
       "snapshot_viewport",
       timeout: min(1.0, max(0.1, captureDeadline.timeIntervalSinceNow)),
       timeoutError: snapshotMainThreadTimeoutError("preparing tree snapshot")
     ) {
-      (
-        viewport: self.safeSnapshotViewport(app: app),
-        interfaceOrientation: self.capturedInterfaceOrientation(app: app)
-      )
+      self.safeSnapshotViewport(app: app, readingOrientation: true)
     }
-    let viewport = geometry.viewport
-    let interfaceOrientation = geometry.interfaceOrientation
     let treeSliceBudget = treeCaptureSliceBudgetOverride ?? treeCaptureSliceBudget
     let slice = min(treeSliceBudget, max(0.5, captureDeadline.timeIntervalSinceNow))
     guard let rootSnapshot = try captureSnapshotRootBounded(app, sliceSeconds: slice) else {
@@ -70,7 +65,6 @@ extension RunnerTests {
       queryRoot: app,
       rootSnapshot: rootSnapshot,
       viewport: viewport,
-      interfaceOrientation: interfaceOrientation,
       keyboardBand: keyboardBand
     )
   }
@@ -140,8 +134,18 @@ extension RunnerTests {
     return nil
   }
 
-  func safeSnapshotViewport(app: XCUIApplication) -> CGRect {
-    safely("SNAPSHOT_VIEWPORT", CGRect.infinite) { snapshotViewport(app: app) }
+
+
+
+  func safeSnapshotViewport(app: XCUIApplication, readingOrientation: Bool) -> SnapshotViewport {
+    safely("SNAPSHOT_VIEWPORT", .missing(reason: .notProvided)) {
+      .reported(
+        box: snapshotAppFrame(app: app),
+        interfaceOrientation: readingOrientation
+          ? capturedInterfaceOrientation(app: app)
+          : RunnerInterfaceOrientation.unknown
+      )
+    }
   }
 
   private func describeSnapshotError(_ error: Error) -> String {
@@ -231,16 +235,12 @@ extension RunnerTests {
     return text.isEmpty ? nil : text
   }
 
-  private func snapshotViewport(app: XCUIApplication) -> CGRect {
+  private func snapshotAppFrame(app: XCUIApplication) -> CGRect {
 #if os(iOS)
-    let appFrame = onScreenWindowFrame(app: app)
+    return onScreenWindowFrame(app: app)
 #else
-    let appFrame = app.frame
+    return app.frame
 #endif
-    if !appFrame.isNull && !appFrame.isEmpty {
-      return appFrame
-    }
-    return .infinite
   }
 
   static func snapshotTraversalIdentity(

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

@@ -513,8 +513,7 @@ extension RunnerTests {
     let normalizedAcquisition = acquisition.replacingNodes(
       SnapshotGeometrySpace.normalized(
         nodes: acquisition.nodes,
-        viewport: acquisition.viewport,
-        interfaceOrientation: acquisition.interfaceOrientation
+        viewport: acquisition.viewport
       )
     )
 
@@ -641,7 +640,7 @@ extension RunnerTests {
       guard Self.structuralOnlyNodeTypes.contains(node.type) else { return false }
       guard !isRootContainer else { return true }
 
-      let isFullScreenContainer = !node.hittable && rootRects.contains { rootRect in
+      let isFullScreenContainer = node.hittable != true && rootRects.contains { rootRect in
         rootRect.x == node.rect.x && rootRect.y == node.rect.y
           && rootRect.width == node.rect.width && rootRect.height == node.rect.height
       }

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

@@ -14,15 +14,12 @@ enum RunnerAccessibilityHealth: String, Equatable {
 
 enum SynthesizedKeyboardPolicy: String, Equatable, Hashable {
   case never
-  case whenAccessibilityHealthy
   case requiredWhenAvailable
 
   func allowsProbe(accessibilityHealth: RunnerAccessibilityHealth) -> Bool {
     switch self {
     case .never:
       return false
-    case .whenAccessibilityHealthy:
-      return accessibilityHealth == .healthy
     case .requiredWhenAvailable:
       return accessibilityHealth != .unavailable
     }
@@ -63,7 +60,6 @@ struct SynthesizedCoordinateContext {
 
   let resolvedWindow: XCUIElement
   let keyboardPolicy: SynthesizedKeyboardPolicy
-  let fallbackPolicy: SynthesizedFallbackPolicy
   let accessibilityHealth: RunnerAccessibilityHealth
 
   func withReferenceFrame(_ frame: CGRect) -> SynthesizedCoordinateContext {
@@ -71,15 +67,10 @@ struct SynthesizedCoordinateContext {
       referenceFrame: frame,
       resolvedWindow: resolvedWindow,
       keyboardPolicy: keyboardPolicy,
-      fallbackPolicy: fallbackPolicy,
       accessibilityHealth: accessibilityHealth
     )
   }
 
-  var allowsXCTestCoordinateFallback: Bool {
-    fallbackPolicy.allowsXCTestCoordinateFallback(accessibilityHealth: accessibilityHealth)
-  }
-
   var allowsKeyboardProbe: Bool {
     keyboardPolicy.allowsProbe(accessibilityHealth: accessibilityHealth)
   }
@@ -115,10 +106,22 @@ func shouldProbeCoordinateTapTextInput(xCTestChannelPenalized: Bool) -> Bool {
   !xCTestChannelPenalized
 }
 
-func sequenceHasSynthesizedCoordinateStep(_ steps: [SequenceStep]) -> Bool {
-  steps.contains { step in
-    step.synthesized == true && step.kind == "tap"
-  }
+
+func synthesizedPolicyKind(forSequenceStep step: SequenceStep) -> SynthesizedGesturePolicyKind? {
+  step.synthesized == true && step.kind == "tap" ? .coordinateTap : nil
+}
+
+
+enum SynthesizedGestureAttempt {
+  case performed(timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double))
+
+  case xctestFallback(message: String, hint: String?)
+
+  case refused(
+    timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double),
+    message: String,
+    hint: String?
+  )
 }
 
 extension RunnerTests {
@@ -126,11 +129,36 @@ extension RunnerTests {
     steps: [SequenceStep],
     app: XCUIApplication
   ) -> SynthesizedCoordinateContext? {
-    guard sequenceHasSynthesizedCoordinateStep(steps) else { return nil }
-    return synthesizedCoordinateContext(
-      app: app,
-      policy: synthesizedGesturePolicy(.synthesizedDrag)
+    guard let kind = steps.lazy.compactMap(synthesizedPolicyKind(forSequenceStep:)).first else {
+      return nil
+    }
+    return synthesizedCoordinateContext(app: app, policy: synthesizedGesturePolicy(kind))
+  }
+
+
+
+  func performSynthesizedGesture(
+    _ app: XCUIApplication,
+    kind: SynthesizedGesturePolicyKind,
+    context: SynthesizedCoordinateContext?,
+    synthesize: () -> RunnerInteractionOutcome
+  ) -> SynthesizedGestureAttempt {
+    let (timing, outcome) = performGesture(app, idleTimeout: false, synthesize)
+    guard case .unsupported(let message, let hint) = outcome else {
+      logSynthesizedGesturePolicyDecision(kind: kind, context: context, fallbackAttempted: false)
+      return .performed(timing: timing)
+    }
+    let fallbackAllowed = synthesizedGesturePolicy(kind).fallbackPolicy.allowsXCTestCoordinateFallback(
+      accessibilityHealth: context?.accessibilityHealth ?? runnerAccessibilityHealth
+    )
+    logSynthesizedGesturePolicyDecision(
+      kind: kind,
+      context: context,
+      fallbackAttempted: fallbackAllowed
     )
+    return fallbackAllowed
+      ? .xctestFallback(message: message, hint: hint)
+      : .refused(timing: timing, message: message, hint: hint)
   }
 
   func logSynthesizedGesturePolicyDecision(
@@ -162,11 +190,12 @@ extension RunnerTests {
       return "AGENT_DEVICE_RUNNER_SYNTHESIZED_GESTURE_POLICY kind=\(kind.rawValue)"
         + " context=unavailable fallbackAttempted=\(fallbackAttempted)"
     }
+    let fallbackPolicy = synthesizedGesturePolicy(kind).fallbackPolicy
     return "AGENT_DEVICE_RUNNER_SYNTHESIZED_GESTURE_POLICY kind=\(kind.rawValue)"
       + " axHealth=\(context.accessibilityHealth.rawValue) frameSource=window"
       + " keyboardPolicy=\(context.keyboardPolicy.rawValue)"
-      + " fallbackPolicy=\(context.fallbackPolicy.rawValue)"
-      + " fallbackAllowed=\(context.allowsXCTestCoordinateFallback)"
+      + " fallbackPolicy=\(fallbackPolicy.rawValue)"
+      + " fallbackAllowed=\(fallbackPolicy.allowsXCTestCoordinateFallback(accessibilityHealth: context.accessibilityHealth))"
       + " fallbackAttempted=\(fallbackAttempted)"
   }
 }

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

@@ -384,7 +384,6 @@ extension RunnerTests {
       referenceFrame: referenceFrame,
       resolvedWindow: window,
       keyboardPolicy: policy.keyboardPolicy,
-      fallbackPolicy: policy.fallbackPolicy,
       accessibilityHealth: health
     )
 #else

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

@@ -270,11 +270,4 @@ extension RunnerTests {
   ) -> Bool {
     repairMode == .replacement && hasX && hasY && xCTestChannelPenalized
   }
-
-  static func shouldFallbackFromSynthesizedTextEntryFocus(
-    _ outcome: RunnerInteractionOutcome
-  ) -> Bool {
-    if case .unsupported = outcome { return true }
-    return false
-  }
 }

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

@@ -31,27 +31,20 @@ extension RunnerTests {
         app: activeApp,
         policy: synthesizedGesturePolicy(policyKind)
       )
-      let (_, outcome) = performGesture(activeApp, idleTimeout: false) {
+      switch performSynthesizedGesture(activeApp, kind: policyKind, context: context, synthesize: {
         synthesizedTapAt(app: activeApp, x: x, y: y, context: context)
-      }
-      if Self.shouldFallbackFromSynthesizedTextEntryFocus(outcome) {
-        logSynthesizedGesturePolicyDecision(
-          kind: policyKind,
-          context: context,
-          fallbackAttempted: true
-        )
-      } else {
-        logSynthesizedGesturePolicyDecision(
-          kind: policyKind,
-          context: context,
-          fallbackAttempted: false
-        )
+      }) {
+      case .performed:
         resolvedCoordinateContext = context
         resolvedCoordinateTarget = TextEntryTarget(
           element: nil,
           refreshPoint: CGPoint(x: x, y: y),
           prefersFocusedElement: false
         )
+      case .xctestFallback:
+        break
+      case .refused(_, let message, let hint):
+        return unsupportedResponse(message: message, hint: hint)
       }
     }
 #else

package/dist/apple/snapshot-presentation/Sources/AgentDeviceSnapshotPresentation/SnapshotCoordinateSpace.swift

@@ -105,7 +105,7 @@ public enum CoordinateSpaceRotation {
 
 public enum SnapshotGeometrySpace: Equatable {
   case appOrientation
-  case deviceNative(appFrame: CGRect, interfaceOrientation: Int)
+  case deviceNative(appFrame: SnapshotViewport.Box, interfaceOrientation: Int)
 
   public static let quarterTurnTolerance: Double = 1
 
@@ -116,22 +116,26 @@ public enum SnapshotGeometrySpace: Equatable {
     case .deviceNative(let appFrame, let interfaceOrientation):
       return CoordinateSpaceRotation.oriented(
         rect: reportedFrame,
-        in: appFrame,
+        in: appFrame.rect,
         interfaceOrientation: interfaceOrientation
       )
     }
   }
 
+  /// Only a `.reported` viewport carries an orientation, so only it can anchor a rotation.
   public static func space(
     reportedBySurfaceHost isSurfaceHost: Bool,
     reportedFrame: CGRect,
     inheritedFrom inherited: SnapshotGeometrySpace,
-    appFrame: CGRect,
-    interfaceOrientation: Int
+    viewport: SnapshotViewport
   ) -> SnapshotGeometrySpace {
     guard isSurfaceHost else { return inherited }
-    guard namesQuarterTurn(interfaceOrientation) else { return .appOrientation }
-    guard isQuarterTurned(reportedFrame, relativeTo: appFrame) else { return .appOrientation }
+    guard case .reported(let appFrame, let interfaceOrientation) = viewport,
+      namesQuarterTurn(interfaceOrientation),
+      isQuarterTurned(reportedFrame, relativeTo: appFrame.rect)
+    else {
+      return .appOrientation
+    }
     return .deviceNative(appFrame: appFrame, interfaceOrientation: interfaceOrientation)
   }
 
@@ -145,7 +149,7 @@ public enum SnapshotGeometrySpace: Equatable {
   }
 
   private static func isQuarterTurned(_ frame: CGRect, relativeTo appFrame: CGRect) -> Bool {
-    guard isPlottable(frame), isPlottable(appFrame),
+    guard SnapshotGeometry.isPositiveFinite(frame),
       abs(appFrame.width - appFrame.height) > quarterTurnTolerance
     else {
       return false
@@ -153,19 +157,12 @@ public enum SnapshotGeometrySpace: Equatable {
     return abs(frame.width - appFrame.height) <= quarterTurnTolerance
       && abs(frame.height - appFrame.width) <= quarterTurnTolerance
   }
-
-  private static func isPlottable(_ frame: CGRect) -> Bool {
-    frame.origin.x.isFinite && frame.origin.y.isFinite
-      && frame.width.isFinite && frame.height.isFinite
-      && frame.width > 0 && frame.height > 0
-  }
 }
 
 extension SnapshotGeometrySpace {
   public static func normalized(
     nodes: [RawAXNode],
-    viewport: CGRect,
-    interfaceOrientation: Int
+    viewport: SnapshotViewport
   ) -> [RawAXNode] {
     let carriers = SnapshotVisibilityFold.visibilityExemptCarrierTypes
     var spaces = [SnapshotGeometrySpace](repeating: .appOrientation, count: nodes.count)
@@ -180,16 +177,16 @@ extension SnapshotGeometrySpace {
         ),
         reportedFrame: node.rect.cgRect,
         inheritedFrom: parentIndex.map { spaces[$0] } ?? .appOrientation,
-        appFrame: viewport,
-        interfaceOrientation: interfaceOrientation
+        viewport: viewport
       )
       spaces[position] = nodeSpace
       let frame = nodeSpace.orientedFrame(of: node.rect.cgRect)
       result.append(
         node.replacing(
           rect: SnapshotRect(frame),
-          hittable: node.parentIndex != nil
-            && SnapshotGeometry.isGeometricallyActionable(
+          hittable: node.parentIndex == nil
+            ? false
+            : SnapshotGeometry.isGeometricallyActionable(
               enabled: node.enabled,
               frame: frame,
               viewport: viewport

package/dist/apple/snapshot-presentation/Sources/AgentDeviceSnapshotPresentation/SnapshotGeometry.swift

@@ -2,14 +2,23 @@ import Foundation
 import CoreGraphics
 
 public enum SnapshotGeometry {
+  /// Twin of `isPositiveFiniteRect` in `packages/kernel/src/rect.ts`. `CGRect.infinite` is built
+  /// from finite components, so it is refused by identity.
+  public static func isPositiveFinite(_ rect: CGRect) -> Bool {
+    !rect.isInfinite
+      && rect.origin.x.isFinite && rect.origin.y.isFinite
+      && rect.size.width.isFinite && rect.size.height.isFinite
+      && rect.size.width > 0 && rect.size.height > 0
+  }
+
   public static func effectiveFrame(
     reportedFrame: CGRect,
-    viewport: CGRect,
+    viewport: SnapshotViewport,
     ancestorClip: CGRect?
   ) -> CGRect {
     var frame = reportedFrame
-    if !viewport.isInfinite {
-      frame = clipped(frame, to: viewport)
+    if let box = viewport.rect {
+      frame = clipped(frame, to: box)
     }
     if let ancestorClip {
       frame = clipped(frame, to: ancestorClip)
@@ -34,15 +43,18 @@ public enum SnapshotGeometry {
     )
   }
 
+  /// The shared `hittable` predicate (#1933), twin of `isGeometricallyActionable` in
+  /// `packages/kernel/src/rect.ts`, with `CGRect.contains`'s half-open right and bottom edges.
+  /// `nil` when only containment is left to decide and the capture has no viewport box: the node's
+  /// `hittable` is then absent on the wire, as it is on the host bridge (#2891).
   public static func isGeometricallyActionable(
     enabled: Bool,
     frame: CGRect,
-    viewport: CGRect
-  ) -> Bool {
-    guard enabled, !frame.isNull, !frame.isEmpty else { return false }
-    if viewport.isInfinite { return true }
-    let center = CGPoint(x: frame.midX, y: frame.midY)
-    return viewport.contains(center)
+    viewport: SnapshotViewport
+  ) -> Bool? {
+    guard enabled, isPositiveFinite(frame) else { return false }
+    guard let box = viewport.rect else { return nil }
+    return box.contains(CGPoint(x: frame.midX, y: frame.midY))
   }
 
   private static func clipped(_ frame: CGRect, to clip: CGRect) -> CGRect {

package/dist/apple/snapshot-presentation/Sources/AgentDeviceSnapshotPresentation/SnapshotModels.swift

@@ -38,7 +38,8 @@ public struct RawAXNode: Equatable {
   public let enabled: Bool
   public let focused: Bool?
   public let selected: Bool?
-  public var hittable: Bool
+  /// Geometric actionability; `nil` when the capture has no viewport box to decide it against.
+  public var hittable: Bool?
   public let depth: Int
   public let parentIndex: Int?
   public let hiddenContentAbove: Bool?
@@ -55,7 +56,7 @@ public struct RawAXNode: Equatable {
     enabled: Bool,
     focused: Bool?,
     selected: Bool?,
-    hittable: Bool,
+    hittable: Bool?,
     depth: Int,
     parentIndex: Int?,
     hiddenContentAbove: Bool?,
@@ -79,7 +80,7 @@ public struct RawAXNode: Equatable {
     self.actions = actions
   }
 
-  func replacing(rect: SnapshotRect, hittable: Bool) -> RawAXNode {
+  func replacing(rect: SnapshotRect, hittable: Bool?) -> RawAXNode {
     var updated = self
     updated.rect = rect
     updated.hittable = hittable
@@ -153,15 +154,65 @@ public struct PresentationOptions: Equatable {
   }
 }
 
+/// What a capture knows about the viewport hosting its tree: the three cases of the host's
+/// `IosViewportEvidence` (#2891). No rectangle stands for "unknown".
+public enum SnapshotViewport: Equatable {
+  /// A box `SnapshotGeometry.isPositiveFinite` accepted. Only the factories below construct one.
+  public struct Box: Equatable {
+    public let rect: CGRect
+
+    init(positiveFinite rect: CGRect) {
+      self.rect = rect
+    }
+  }
+
+  /// The platform's box for the app's surface, with the interface orientation read in the same hop.
+  /// Only this case can anchor a rotation (#2612).
+  case reported(Box, interfaceOrientation: Int)
+  /// A box the capture inferred from its own root element. It clips and contains, and carries no
+  /// orientation, so it cannot anchor a rotation.
+  case derived(Box)
+  case missing(reason: MissingReason)
+
+  public enum MissingReason: Equatable {
+    /// The read was skipped or raised.
+    case notProvided
+    /// The box read is one `SnapshotGeometry.isPositiveFinite` refuses.
+    case invalid
+  }
+
+  public var rect: CGRect? {
+    switch self {
+    case .reported(let box, _), .derived(let box):
+      return box.rect
+    case .missing:
+      return nil
+    }
+  }
+
+  public static func reported(
+    box: CGRect,
+    interfaceOrientation: Int = RunnerInterfaceOrientation.unknown
+  ) -> SnapshotViewport {
+    SnapshotGeometry.isPositiveFinite(box)
+      ? .reported(Box(positiveFinite: box), interfaceOrientation: interfaceOrientation)
+      : .missing(reason: .invalid)
+  }
+
+  public static func derived(box: CGRect) -> SnapshotViewport {
+    SnapshotGeometry.isPositiveFinite(box)
+      ? .derived(Box(positiveFinite: box))
+      : .missing(reason: .invalid)
+  }
+}
+
 public struct SnapshotAcquisition {
   public let hint: CaptureHint
   public var nodes: [RawAXNode]
   public let truncated: Bool
   public let effectiveDepth: Int?
   public var customActions: SnapshotCustomActionCoverage?
-  public let viewport: CGRect
-  /// The app's interface orientation, consumed by the one `normalized` pass; `unknown` turns nothing.
-  public let interfaceOrientation: Int
+  public let viewport: SnapshotViewport
 
   public init(
     hint: CaptureHint,
@@ -169,8 +220,7 @@ public struct SnapshotAcquisition {
     truncated: Bool,
     effectiveDepth: Int?,
     customActions: SnapshotCustomActionCoverage? = nil,
-    viewport: CGRect,
-    interfaceOrientation: Int = 0
+    viewport: SnapshotViewport
   ) {
     self.hint = hint
     self.nodes = nodes
@@ -178,7 +228,6 @@ public struct SnapshotAcquisition {
     self.effectiveDepth = effectiveDepth
     self.customActions = customActions
     self.viewport = viewport
-    self.interfaceOrientation = interfaceOrientation
   }
 
   public func replacingNodes(_ nodes: [RawAXNode]) -> SnapshotAcquisition {
@@ -226,7 +275,7 @@ public struct PresentedNode: Codable, Equatable {
   public let enabled: Bool
   public let focused: Bool?
   public let selected: Bool?
-  public let hittable: Bool
+  public let hittable: Bool?
   public let depth: Int
   public let parentIndex: Int?
   public let hiddenContentAbove: Bool?

package/dist/apple/snapshot-presentation/Sources/AgentDeviceSnapshotPresentation/SnapshotPresentationInvariant.swift

@@ -1,6 +1,7 @@
 import Foundation
 import CoreGraphics
 
+/// With no viewport box the cumulative clip has no root, so containment has nothing to violate.
 public enum SnapshotPresentationInvariant {
   struct ValidationStats: Equatable {
     let parentClipLookups: Int
@@ -12,7 +13,7 @@ public enum SnapshotPresentationInvariant {
 
   public static func validateRegular(
     _ nodes: [SnapshotPresentationNode],
-    viewport: CGRect,
+    viewport: SnapshotViewport,
     policy: SnapshotVisibilityFold.Policy
   ) throws {
     _ = try validateRegularWithStats(nodes, viewport: viewport, policy: policy)
@@ -20,24 +21,25 @@ public enum SnapshotPresentationInvariant {
 
   static func validateRegularWithStats(
     _ nodes: [SnapshotPresentationNode],
-    viewport: CGRect,
+    viewport: SnapshotViewport,
     policy: SnapshotVisibilityFold.Policy
   ) throws -> ValidationStats {
     var parentClipLookups = 0
-    var clipIncludingNodeByIndex: [Int: CGRect] = [:]
+    var clipIncludingNodeByIndex: [Int: CGRect?] = [:]
     clipIncludingNodeByIndex.reserveCapacity(nodes.count)
+    let rootClip = viewport.rect
 
     for node in nodes {
-      let ancestorClip: CGRect
+      let ancestorClip: CGRect?
       if let parentIndex = node.raw.parentIndex {
         parentClipLookups += 1
-        ancestorClip = clipIncludingNodeByIndex[parentIndex] ?? viewport
+        ancestorClip = clipIncludingNodeByIndex[parentIndex] ?? rootClip
       } else {
-        ancestorClip = viewport
+        ancestorClip = rootClip
       }
 
       let frame = node.effectiveRect.cgRect
-      let clipIncludingNode: CGRect
+      let clipIncludingNode: CGRect?
       if policy == .cursorProjected,
         SnapshotVisibilityFold.scrollContainerTypeNames.contains(node.raw.type),
         !frame.isNull,
@@ -50,7 +52,7 @@ public enum SnapshotPresentationInvariant {
       clipIncludingNodeByIndex[node.raw.index] = clipIncludingNode
 
       guard !frame.isNull, !frame.isEmpty else {
-        if node.raw.hittable {
+        if node.raw.hittable == true {
           throw SnapshotPresentationFailure.regularDegenerateNodeIsActionable(
             index: node.raw.index,
             frame: node.effectiveRect
@@ -59,11 +61,11 @@ public enum SnapshotPresentationInvariant {
         continue
       }
 
-      guard contains(frame, in: ancestorClip) else {
+      if let clip = ancestorClip, !contains(frame, in: clip) {
         throw SnapshotPresentationFailure.regularNodeOutsideCumulativeClip(
           index: node.raw.index,
           frame: node.effectiveRect,
-          clip: SnapshotRect(ancestorClip)
+          clip: SnapshotRect(clip)
         )
       }
     }

package/dist/apple/snapshot-presentation/Sources/AgentDeviceSnapshotPresentation/SnapshotVisibilityFold.swift

@@ -100,7 +100,7 @@ public enum SnapshotVisibilityFold {
   public static func traversalDecision(
     for node: RawAXNode,
     parent: TraversalState,
-    viewport: CGRect,
+    viewport: SnapshotViewport,
     interactiveOnly: Bool,
     hasChildren: Bool,
     policy: Policy
@@ -153,7 +153,7 @@ public enum SnapshotVisibilityFold {
 
   public static func fold(
     _ nodes: [RawAXNode],
-    viewport: CGRect,
+    viewport: SnapshotViewport,
     interactiveOnly: Bool,
     policy: Policy
   ) -> [SnapshotPresentationNode] {
@@ -203,12 +203,17 @@ public enum SnapshotVisibilityFold {
               enabled: node.enabled,
               focused: node.focused,
               selected: node.selected,
-              hittable: node.parentIndex != nil && node.hittable
-                && SnapshotGeometry.isGeometricallyActionable(
-                  enabled: node.enabled,
-                  frame: decision.effectiveFrame,
-                  viewport: viewport
-                ),
+              hittable: node.parentIndex == nil
+                ? false
+                : node.hittable.flatMap { sourceHittable in
+                  sourceHittable
+                    ? SnapshotGeometry.isGeometricallyActionable(
+                      enabled: node.enabled,
+                      frame: decision.effectiveFrame,
+                      viewport: viewport
+                    )
+                    : false
+                },
               depth: outDepth,
               parentIndex: keptIndex,
               hiddenContentAbove: node.hiddenContentAbove,